gpg: New card function agent_scd_keypairinfo.
[gnupg.git] / g10 / export.c
1 /* export.c - Export keys in the OpenPGP defined format.
2  * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004,
3  *               2005, 2010 Free Software Foundation, Inc.
4  * Copyright (C) 1998-2016  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 <https://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
28 #include "gpg.h"
29 #include "options.h"
30 #include "packet.h"
31 #include "../common/status.h"
32 #include "keydb.h"
33 #include "../common/util.h"
34 #include "main.h"
35 #include "../common/i18n.h"
36 #include "../common/membuf.h"
37 #include "../common/host2net.h"
38 #include "../common/zb32.h"
39 #include "../common/recsel.h"
40 #include "../common/mbox-util.h"
41 #include "../common/init.h"
42 #include "trustdb.h"
43 #include "call-agent.h"
44 #include "key-clean.h"
45
46
47 /* An object to keep track of subkeys. */
48 struct subkey_list_s
49 {
50   struct subkey_list_s *next;
51   u32 kid[2];
52 };
53 typedef struct subkey_list_s *subkey_list_t;
54
55
56 /* An object to track statistics for export operations.  */
57 struct export_stats_s
58 {
59   ulong count;            /* Number of processed keys.        */
60   ulong secret_count;     /* Number of secret keys seen.      */
61   ulong exported;         /* Number of actual exported keys.  */
62 };
63
64
65 /* A global variable to store the selector created from
66  * --export-filter keep-uid=EXPR.
67  * --export-filter drop-subkey=EXPR.
68  *
69  * FIXME: We should put this into the CTRL object but that requires a
70  * lot more changes right now.
71  */
72 static recsel_expr_t export_keep_uid;
73 static recsel_expr_t export_drop_subkey;
74
75
76
77 /* Local prototypes.  */
78 static int do_export (ctrl_t ctrl, strlist_t users, int secret,
79                       unsigned int options, export_stats_t stats);
80 static int do_export_stream (ctrl_t ctrl, iobuf_t out,
81                              strlist_t users, int secret,
82                              kbnode_t *keyblock_out, unsigned int options,
83                              export_stats_t stats, int *any);
84 static gpg_error_t print_pka_or_dane_records
85 /**/                 (iobuf_t out, kbnode_t keyblock, PKT_public_key *pk,
86                       const void *data, size_t datalen,
87                       int print_pka, int print_dane);
88
89 \f
90 static void
91 cleanup_export_globals (void)
92 {
93   recsel_release (export_keep_uid);
94   export_keep_uid = NULL;
95   recsel_release (export_drop_subkey);
96   export_drop_subkey = NULL;
97 }
98
99
100 /* Option parser for export options.  See parse_options for
101    details.  */
102 int
103 parse_export_options(char *str,unsigned int *options,int noisy)
104 {
105   struct parse_options export_opts[]=
106     {
107       {"export-local-sigs",EXPORT_LOCAL_SIGS,NULL,
108        N_("export signatures that are marked as local-only")},
109       {"export-attributes",EXPORT_ATTRIBUTES,NULL,
110        N_("export attribute user IDs (generally photo IDs)")},
111       {"export-sensitive-revkeys",EXPORT_SENSITIVE_REVKEYS,NULL,
112        N_("export revocation keys marked as \"sensitive\"")},
113       {"export-clean",EXPORT_CLEAN,NULL,
114        N_("remove unusable parts from key during export")},
115       {"export-minimal",EXPORT_MINIMAL|EXPORT_CLEAN,NULL,
116        N_("remove as much as possible from key during export")},
117       {"export-drop-uids", EXPORT_DROP_UIDS, NULL,
118        N_("Do not export user id or attribute packets")},
119
120       {"export-pka", EXPORT_PKA_FORMAT, NULL, NULL },
121       {"export-dane", EXPORT_DANE_FORMAT, NULL, NULL },
122
123       {"backup", EXPORT_BACKUP, NULL,
124        N_("use the GnuPG key backup format")},
125       {"export-backup", EXPORT_BACKUP, NULL, NULL },
126
127       /* Aliases for backward compatibility */
128       {"include-local-sigs",EXPORT_LOCAL_SIGS,NULL,NULL},
129       {"include-attributes",EXPORT_ATTRIBUTES,NULL,NULL},
130       {"include-sensitive-revkeys",EXPORT_SENSITIVE_REVKEYS,NULL,NULL},
131       /* dummy */
132       {"export-unusable-sigs",0,NULL,NULL},
133       {"export-clean-sigs",0,NULL,NULL},
134       {"export-clean-uids",0,NULL,NULL},
135       {NULL,0,NULL,NULL}
136       /* add tags for include revoked and disabled? */
137     };
138   int rc;
139
140   rc = parse_options (str, options, export_opts, noisy);
141   if (!rc)
142     return 0;
143
144   /* Alter other options we want or don't want for restore.  */
145   if ((*options & EXPORT_BACKUP))
146     {
147       *options |= (EXPORT_LOCAL_SIGS | EXPORT_ATTRIBUTES
148                    | EXPORT_SENSITIVE_REVKEYS);
149       *options &= ~(EXPORT_CLEAN | EXPORT_MINIMAL
150                     | EXPORT_PKA_FORMAT | EXPORT_DANE_FORMAT);
151     }
152   /* Dropping uids also means to drop attributes.  */
153   if ((*options & EXPORT_DROP_UIDS))
154     *options &= ~(EXPORT_ATTRIBUTES);
155   return rc;
156 }
157
158
159 /* Parse and set an export filter from string.  STRING has the format
160  * "NAME=EXPR" with NAME being the name of the filter.  Spaces before
161  * and after NAME are not allowed.  If this function is called several
162  * times all expressions for the same NAME are concatenated.
163  * Supported filter names are:
164  *
165  *  - keep-uid :: If the expression evaluates to true for a certain
166  *                user ID packet, that packet and all it dependencies
167  *                will be exported.  The expression may use these
168  *                variables:
169  *
170  *                - uid  :: The entire user ID.
171  *                - mbox :: The mail box part of the user ID.
172  *                - primary :: Evaluate to true for the primary user ID.
173  *
174  *  - drop-subkey :: If the expression evaluates to true for a subkey
175  *                packet that subkey and all it dependencies will be
176  *                remove from the keyblock.  The expression may use these
177  *                variables:
178  *
179  *                - secret   :: 1 for a secret subkey, else 0.
180  *                - key_algo :: Public key algorithm id
181  */
182 gpg_error_t
183 parse_and_set_export_filter (const char *string)
184 {
185   gpg_error_t err;
186
187   /* Auto register the cleanup function.  */
188   register_mem_cleanup_func (cleanup_export_globals);
189
190   if (!strncmp (string, "keep-uid=", 9))
191     err = recsel_parse_expr (&export_keep_uid, string+9);
192   else if (!strncmp (string, "drop-subkey=", 12))
193     err = recsel_parse_expr (&export_drop_subkey, string+12);
194   else
195     err = gpg_error (GPG_ERR_INV_NAME);
196
197   return err;
198 }
199
200
201 /* Create a new export stats object initialized to zero.  On error
202    returns NULL and sets ERRNO.  */
203 export_stats_t
204 export_new_stats (void)
205 {
206   export_stats_t stats;
207
208   return xtrycalloc (1, sizeof *stats);
209 }
210
211
212 /* Release an export stats object.  */
213 void
214 export_release_stats (export_stats_t stats)
215 {
216   xfree (stats);
217 }
218
219
220 /* Print export statistics using the status interface.  */
221 void
222 export_print_stats (export_stats_t stats)
223 {
224   if (!stats)
225     return;
226
227   if (is_status_enabled ())
228     {
229       char buf[15*20];
230
231       snprintf (buf, sizeof buf, "%lu %lu %lu",
232                 stats->count,
233                 stats->secret_count,
234                 stats->exported );
235       write_status_text (STATUS_EXPORT_RES, buf);
236     }
237 }
238
239
240 /*
241  * Export public keys (to stdout or to --output FILE).
242  *
243  * Depending on opt.armor the output is armored.  OPTIONS are defined
244  * in main.h.  If USERS is NULL, all keys will be exported.  STATS is
245  * either an export stats object for update or NULL.
246  *
247  * This function is the core of "gpg --export".
248  */
249 int
250 export_pubkeys (ctrl_t ctrl, strlist_t users, unsigned int options,
251                 export_stats_t stats)
252 {
253   return do_export (ctrl, users, 0, options, stats);
254 }
255
256
257 /*
258  * Export secret keys (to stdout or to --output FILE).
259  *
260  * Depending on opt.armor the output is armored.  OPTIONS are defined
261  * in main.h.  If USERS is NULL, all secret keys will be exported.
262  * STATS is either an export stats object for update or NULL.
263  *
264  * This function is the core of "gpg --export-secret-keys".
265  */
266 int
267 export_seckeys (ctrl_t ctrl, strlist_t users, unsigned int options,
268                 export_stats_t stats)
269 {
270   return do_export (ctrl, users, 1, options, stats);
271 }
272
273
274 /*
275  * Export secret sub keys (to stdout or to --output FILE).
276  *
277  * This is the same as export_seckeys but replaces the primary key by
278  * a stub key.  Depending on opt.armor the output is armored.  OPTIONS
279  * are defined in main.h.  If USERS is NULL, all secret subkeys will
280  * be exported.  STATS is either an export stats object for update or
281  * NULL.
282  *
283  * This function is the core of "gpg --export-secret-subkeys".
284  */
285 int
286 export_secsubkeys (ctrl_t ctrl, strlist_t users, unsigned int options,
287                    export_stats_t stats)
288 {
289   return do_export (ctrl, users, 2, options, stats);
290 }
291
292
293 /*
294  * Export a single key into a memory buffer.  STATS is either an
295  * export stats object for update or NULL.
296  */
297 gpg_error_t
298 export_pubkey_buffer (ctrl_t ctrl, const char *keyspec, unsigned int options,
299                       export_stats_t stats,
300                       kbnode_t *r_keyblock, void **r_data, size_t *r_datalen)
301 {
302   gpg_error_t err;
303   iobuf_t iobuf;
304   int any;
305   strlist_t helplist;
306
307   *r_keyblock = NULL;
308   *r_data = NULL;
309   *r_datalen = 0;
310
311   helplist = NULL;
312   if (!add_to_strlist_try (&helplist, keyspec))
313     return gpg_error_from_syserror ();
314
315   iobuf = iobuf_temp ();
316   err = do_export_stream (ctrl, iobuf, helplist, 0, r_keyblock, options,
317                           stats, &any);
318   if (!err && !any)
319     err = gpg_error (GPG_ERR_NOT_FOUND);
320   if (!err)
321     {
322       const void *src;
323       size_t datalen;
324
325       iobuf_flush_temp (iobuf);
326       src = iobuf_get_temp_buffer (iobuf);
327       datalen = iobuf_get_temp_length (iobuf);
328       if (!datalen)
329         err = gpg_error (GPG_ERR_NO_PUBKEY);
330       else if (!(*r_data = xtrymalloc (datalen)))
331         err = gpg_error_from_syserror ();
332       else
333         {
334           memcpy (*r_data, src, datalen);
335           *r_datalen = datalen;
336         }
337     }
338   iobuf_close (iobuf);
339   free_strlist (helplist);
340   if (err && *r_keyblock)
341     {
342       release_kbnode (*r_keyblock);
343       *r_keyblock = NULL;
344     }
345   return err;
346 }
347
348
349 /* Export the keys identified by the list of strings in USERS.  If
350    Secret is false public keys will be exported.  With secret true
351    secret keys will be exported; in this case 1 means the entire
352    secret keyblock and 2 only the subkeys.  OPTIONS are the export
353    options to apply.  */
354 static int
355 do_export (ctrl_t ctrl, strlist_t users, int secret, unsigned int options,
356            export_stats_t stats)
357 {
358   IOBUF out = NULL;
359   int any, rc;
360   armor_filter_context_t *afx = NULL;
361   compress_filter_context_t zfx;
362
363   memset( &zfx, 0, sizeof zfx);
364
365   rc = open_outfile (-1, NULL, 0, !!secret, &out );
366   if (rc)
367     return rc;
368
369   if ( opt.armor && !(options & (EXPORT_PKA_FORMAT|EXPORT_DANE_FORMAT)) )
370     {
371       afx = new_armor_context ();
372       afx->what = secret? 5 : 1;
373       push_armor_filter (afx, out);
374     }
375
376   rc = do_export_stream (ctrl, out, users, secret, NULL, options, stats, &any);
377
378   if ( rc || !any )
379     iobuf_cancel (out);
380   else
381     iobuf_close (out);
382   release_armor_context (afx);
383   return rc;
384 }
385
386
387
388 /* Release an entire subkey list. */
389 static void
390 release_subkey_list (subkey_list_t list)
391 {
392   while (list)
393     {
394       subkey_list_t tmp = list->next;;
395       xfree (list);
396       list = tmp;
397     }
398 }
399
400
401 /* Returns true if NODE is a subkey and contained in LIST. */
402 static int
403 subkey_in_list_p (subkey_list_t list, KBNODE node)
404 {
405   if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY
406       || node->pkt->pkttype == PKT_SECRET_SUBKEY )
407     {
408       u32 kid[2];
409
410       keyid_from_pk (node->pkt->pkt.public_key, kid);
411
412       for (; list; list = list->next)
413         if (list->kid[0] == kid[0] && list->kid[1] == kid[1])
414           return 1;
415     }
416   return 0;
417 }
418
419 /* Allocate a new subkey list item from NODE. */
420 static subkey_list_t
421 new_subkey_list_item (KBNODE node)
422 {
423   subkey_list_t list = xcalloc (1, sizeof *list);
424
425   if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY
426       || node->pkt->pkttype == PKT_SECRET_SUBKEY)
427     keyid_from_pk (node->pkt->pkt.public_key, list->kid);
428
429   return list;
430 }
431
432
433 /* Helper function to check whether the subkey at NODE actually
434    matches the description at DESC.  The function returns true if the
435    key under question has been specified by an exact specification
436    (keyID or fingerprint) and does match the one at NODE.  It is
437    assumed that the packet at NODE is either a public or secret
438    subkey. */
439 static int
440 exact_subkey_match_p (KEYDB_SEARCH_DESC *desc, KBNODE node)
441 {
442   u32 kid[2];
443   byte fpr[MAX_FINGERPRINT_LEN];
444   size_t fprlen;
445   int result = 0;
446
447   switch(desc->mode)
448     {
449     case KEYDB_SEARCH_MODE_SHORT_KID:
450     case KEYDB_SEARCH_MODE_LONG_KID:
451       keyid_from_pk (node->pkt->pkt.public_key, kid);
452       break;
453
454     case KEYDB_SEARCH_MODE_FPR:
455       fingerprint_from_pk (node->pkt->pkt.public_key, fpr, &fprlen);
456       break;
457
458     default:
459       break;
460     }
461
462   switch(desc->mode)
463     {
464     case KEYDB_SEARCH_MODE_SHORT_KID:
465       if (desc->u.kid[1] == kid[1])
466         result = 1;
467       break;
468
469     case KEYDB_SEARCH_MODE_LONG_KID:
470       if (desc->u.kid[0] == kid[0] && desc->u.kid[1] == kid[1])
471         result = 1;
472       break;
473
474     case KEYDB_SEARCH_MODE_FPR:
475       if (fprlen == desc->fprlen && !memcmp (desc->u.fpr, fpr, desc->fprlen))
476         result = 1;
477       break;
478
479     default:
480       break;
481     }
482
483   return result;
484 }
485
486
487 /* Return an error if the key represented by the S-expression S_KEY
488  * and the OpenPGP key represented by PK do not use the same curve. */
489 static gpg_error_t
490 match_curve_skey_pk (gcry_sexp_t s_key, PKT_public_key *pk)
491 {
492   gcry_sexp_t curve = NULL;
493   gcry_sexp_t flags = NULL;
494   char *curve_str = NULL;
495   char *flag;
496   const char *oidstr = NULL;
497   gcry_mpi_t curve_as_mpi = NULL;
498   gpg_error_t err;
499   int is_eddsa = 0;
500   int idx = 0;
501
502   if (!(pk->pubkey_algo==PUBKEY_ALGO_ECDH
503         || pk->pubkey_algo==PUBKEY_ALGO_ECDSA
504         || pk->pubkey_algo==PUBKEY_ALGO_EDDSA))
505     return gpg_error (GPG_ERR_PUBKEY_ALGO);
506
507   curve = gcry_sexp_find_token (s_key, "curve", 0);
508   if (!curve)
509     {
510       log_error ("no reported curve\n");
511       return gpg_error (GPG_ERR_UNKNOWN_CURVE);
512     }
513   curve_str = gcry_sexp_nth_string (curve, 1);
514   gcry_sexp_release (curve); curve = NULL;
515   if (!curve_str)
516     {
517       log_error ("no curve name\n");
518       return gpg_error (GPG_ERR_UNKNOWN_CURVE);
519     }
520   oidstr = openpgp_curve_to_oid (curve_str, NULL);
521   if (!oidstr)
522     {
523       log_error ("no OID known for curve '%s'\n", curve_str);
524       xfree (curve_str);
525       return gpg_error (GPG_ERR_UNKNOWN_CURVE);
526     }
527   xfree (curve_str);
528   err = openpgp_oid_from_str (oidstr, &curve_as_mpi);
529   if (err)
530     return err;
531   if (gcry_mpi_cmp (pk->pkey[0], curve_as_mpi))
532     {
533       log_error ("curves do not match\n");
534       gcry_mpi_release (curve_as_mpi);
535       return gpg_error (GPG_ERR_INV_CURVE);
536     }
537   gcry_mpi_release (curve_as_mpi);
538   flags = gcry_sexp_find_token (s_key, "flags", 0);
539   if (flags)
540     {
541       for (idx = 1; idx < gcry_sexp_length (flags); idx++)
542         {
543           flag = gcry_sexp_nth_string (flags, idx);
544           if (flag && (strcmp ("eddsa", flag) == 0))
545             is_eddsa = 1;
546           gcry_free (flag);
547         }
548     }
549   if (is_eddsa != (pk->pubkey_algo == PUBKEY_ALGO_EDDSA))
550     {
551       log_error ("disagreement about EdDSA\n");
552       err = gpg_error (GPG_ERR_INV_CURVE);
553     }
554
555   return err;
556 }
557
558
559 /* Return a canonicalized public key algoithms.  This is used to
560    compare different flavors of algorithms (e.g. ELG and ELG_E are
561    considered the same).  */
562 static enum gcry_pk_algos
563 canon_pk_algo (enum gcry_pk_algos algo)
564 {
565   switch (algo)
566     {
567     case GCRY_PK_RSA:
568     case GCRY_PK_RSA_E:
569     case GCRY_PK_RSA_S: return GCRY_PK_RSA;
570     case GCRY_PK_ELG:
571     case GCRY_PK_ELG_E: return GCRY_PK_ELG;
572     case GCRY_PK_ECC:
573     case GCRY_PK_ECDSA:
574     case GCRY_PK_ECDH: return GCRY_PK_ECC;
575     default: return algo;
576     }
577 }
578
579
580 /* Take a cleartext dump of a secret key in PK and change the
581  * parameter array in PK to include the secret parameters.  */
582 static gpg_error_t
583 cleartext_secret_key_to_openpgp (gcry_sexp_t s_key, PKT_public_key *pk)
584 {
585   gpg_error_t err;
586   gcry_sexp_t top_list;
587   gcry_sexp_t key = NULL;
588   char *key_type = NULL;
589   enum gcry_pk_algos pk_algo;
590   struct seckey_info *ski;
591   int idx, sec_start;
592   gcry_mpi_t pub_params[10] = { NULL };
593
594   /* we look for a private-key, then the first element in it tells us
595      the type */
596   top_list = gcry_sexp_find_token (s_key, "private-key", 0);
597   if (!top_list)
598     goto bad_seckey;
599   if (gcry_sexp_length(top_list) != 2)
600     goto bad_seckey;
601   key = gcry_sexp_nth (top_list, 1);
602   if (!key)
603     goto bad_seckey;
604   key_type = gcry_sexp_nth_string(key, 0);
605   pk_algo = gcry_pk_map_name (key_type);
606
607   log_assert (!pk->seckey_info);
608
609   pk->seckey_info = ski = xtrycalloc (1, sizeof *ski);
610   if (!ski)
611     {
612       err = gpg_error_from_syserror ();
613       goto leave;
614     }
615
616   switch (canon_pk_algo (pk_algo))
617     {
618     case GCRY_PK_RSA:
619       if (!is_RSA (pk->pubkey_algo))
620         goto bad_pubkey_algo;
621       err = gcry_sexp_extract_param (key, NULL, "ne",
622                                      &pub_params[0],
623                                      &pub_params[1],
624                                      NULL);
625       for (idx=0; idx < 2 && !err; idx++)
626         if (gcry_mpi_cmp(pk->pkey[idx], pub_params[idx]))
627           err = gpg_error (GPG_ERR_BAD_PUBKEY);
628       if (!err)
629         {
630           for (idx = 2; idx < 6 && !err; idx++)
631             {
632               gcry_mpi_release (pk->pkey[idx]);
633               pk->pkey[idx] = NULL;
634             }
635           err = gcry_sexp_extract_param (key, NULL, "dpqu",
636                                          &pk->pkey[2],
637                                          &pk->pkey[3],
638                                          &pk->pkey[4],
639                                          &pk->pkey[5],
640                                          NULL);
641         }
642       if (!err)
643         {
644           for (idx = 2; idx < 6; idx++)
645             ski->csum += checksum_mpi (pk->pkey[idx]);
646         }
647       break;
648
649     case GCRY_PK_DSA:
650       if (!is_DSA (pk->pubkey_algo))
651         goto bad_pubkey_algo;
652       err = gcry_sexp_extract_param (key, NULL, "pqgy",
653                                      &pub_params[0],
654                                      &pub_params[1],
655                                      &pub_params[2],
656                                      &pub_params[3],
657                                      NULL);
658       for (idx=0; idx < 4 && !err; idx++)
659         if (gcry_mpi_cmp(pk->pkey[idx], pub_params[idx]))
660           err = gpg_error (GPG_ERR_BAD_PUBKEY);
661       if (!err)
662         {
663           gcry_mpi_release (pk->pkey[4]);
664           pk->pkey[4] = NULL;
665           err = gcry_sexp_extract_param (key, NULL, "x",
666                                          &pk->pkey[4],
667                                          NULL);
668         }
669       if (!err)
670         ski->csum += checksum_mpi (pk->pkey[4]);
671       break;
672
673     case GCRY_PK_ELG:
674       if (!is_ELGAMAL (pk->pubkey_algo))
675         goto bad_pubkey_algo;
676       err = gcry_sexp_extract_param (key, NULL, "pgy",
677                                      &pub_params[0],
678                                      &pub_params[1],
679                                      &pub_params[2],
680                                      NULL);
681       for (idx=0; idx < 3 && !err; idx++)
682         if (gcry_mpi_cmp(pk->pkey[idx], pub_params[idx]))
683           err = gpg_error (GPG_ERR_BAD_PUBKEY);
684       if (!err)
685         {
686           gcry_mpi_release (pk->pkey[3]);
687           pk->pkey[3] = NULL;
688           err = gcry_sexp_extract_param (key, NULL, "x",
689                                          &pk->pkey[3],
690                                          NULL);
691         }
692       if (!err)
693         ski->csum += checksum_mpi (pk->pkey[3]);
694       break;
695
696     case GCRY_PK_ECC:
697       err = match_curve_skey_pk (key, pk);
698       if (err)
699         goto leave;
700       if (!err)
701         err = gcry_sexp_extract_param (key, NULL, "q",
702                                        &pub_params[0],
703                                        NULL);
704       if (!err && (gcry_mpi_cmp(pk->pkey[1], pub_params[0])))
705         err = gpg_error (GPG_ERR_BAD_PUBKEY);
706
707       sec_start = 2;
708       if (pk->pubkey_algo == PUBKEY_ALGO_ECDH)
709         sec_start += 1;
710       if (!err)
711         {
712           gcry_mpi_release (pk->pkey[sec_start]);
713           pk->pkey[sec_start] = NULL;
714           err = gcry_sexp_extract_param (key, NULL, "d",
715                                          &pk->pkey[sec_start],
716                                          NULL);
717         }
718
719       if (!err)
720         ski->csum += checksum_mpi (pk->pkey[sec_start]);
721       break;
722
723     default:
724       pk->seckey_info = NULL;
725       xfree (ski);
726       err = gpg_error (GPG_ERR_NOT_IMPLEMENTED);
727       break;
728     }
729
730  leave:
731   gcry_sexp_release (top_list);
732   gcry_sexp_release (key);
733   gcry_free (key_type);
734
735   for (idx=0; idx < DIM(pub_params); idx++)
736     gcry_mpi_release (pub_params[idx]);
737   return err;
738
739  bad_pubkey_algo:
740   err = gpg_error (GPG_ERR_PUBKEY_ALGO);
741   goto leave;
742
743  bad_seckey:
744   err = gpg_error (GPG_ERR_BAD_SECKEY);
745   goto leave;
746 }
747
748
749 /* Use the key transfer format given in S_PGP to create the secinfo
750    structure in PK and change the parameter array in PK to include the
751    secret parameters.  */
752 static gpg_error_t
753 transfer_format_to_openpgp (gcry_sexp_t s_pgp, PKT_public_key *pk)
754 {
755   gpg_error_t err;
756   gcry_sexp_t top_list;
757   gcry_sexp_t list = NULL;
758   char *curve = NULL;
759   const char *value;
760   size_t valuelen;
761   char *string;
762   int  idx;
763   int  is_v4, is_protected;
764   enum gcry_pk_algos pk_algo;
765   int  protect_algo = 0;
766   char iv[16];
767   int  ivlen = 0;
768   int  s2k_mode = 0;
769   int  s2k_algo = 0;
770   byte s2k_salt[8];
771   u32  s2k_count = 0;
772   int  is_ecdh = 0;
773   size_t npkey, nskey;
774   gcry_mpi_t skey[10];  /* We support up to 9 parameters.  */
775   int skeyidx = 0;
776   struct seckey_info *ski;
777
778   /* gcry_log_debugsxp ("transferkey", s_pgp); */
779   top_list = gcry_sexp_find_token (s_pgp, "openpgp-private-key", 0);
780   if (!top_list)
781     goto bad_seckey;
782
783   list = gcry_sexp_find_token (top_list, "version", 0);
784   if (!list)
785     goto bad_seckey;
786   value = gcry_sexp_nth_data (list, 1, &valuelen);
787   if (!value || valuelen != 1 || !(value[0] == '3' || value[0] == '4'))
788     goto bad_seckey;
789   is_v4 = (value[0] == '4');
790
791   gcry_sexp_release (list);
792   list = gcry_sexp_find_token (top_list, "protection", 0);
793   if (!list)
794     goto bad_seckey;
795   value = gcry_sexp_nth_data (list, 1, &valuelen);
796   if (!value)
797     goto bad_seckey;
798   if (valuelen == 4 && !memcmp (value, "sha1", 4))
799     is_protected = 2;
800   else if (valuelen == 3 && !memcmp (value, "sum", 3))
801     is_protected = 1;
802   else if (valuelen == 4 && !memcmp (value, "none", 4))
803     is_protected = 0;
804   else
805     goto bad_seckey;
806   if (is_protected)
807     {
808       string = gcry_sexp_nth_string (list, 2);
809       if (!string)
810         goto bad_seckey;
811       protect_algo = gcry_cipher_map_name (string);
812       xfree (string);
813
814       value = gcry_sexp_nth_data (list, 3, &valuelen);
815       if (!value || !valuelen || valuelen > sizeof iv)
816         goto bad_seckey;
817       memcpy (iv, value, valuelen);
818       ivlen = valuelen;
819
820       string = gcry_sexp_nth_string (list, 4);
821       if (!string)
822         goto bad_seckey;
823       s2k_mode = strtol (string, NULL, 10);
824       xfree (string);
825
826       string = gcry_sexp_nth_string (list, 5);
827       if (!string)
828         goto bad_seckey;
829       s2k_algo = gcry_md_map_name (string);
830       xfree (string);
831
832       value = gcry_sexp_nth_data (list, 6, &valuelen);
833       if (!value || !valuelen || valuelen > sizeof s2k_salt)
834         goto bad_seckey;
835       memcpy (s2k_salt, value, valuelen);
836
837       string = gcry_sexp_nth_string (list, 7);
838       if (!string)
839         goto bad_seckey;
840       s2k_count = strtoul (string, NULL, 10);
841       xfree (string);
842     }
843
844   /* Parse the gcrypt PK algo and check that it is okay.  */
845   gcry_sexp_release (list);
846   list = gcry_sexp_find_token (top_list, "algo", 0);
847   if (!list)
848     goto bad_seckey;
849   string = gcry_sexp_nth_string (list, 1);
850   if (!string)
851     goto bad_seckey;
852   pk_algo = gcry_pk_map_name (string);
853   xfree (string); string = NULL;
854   if (gcry_pk_algo_info (pk_algo, GCRYCTL_GET_ALGO_NPKEY, NULL, &npkey)
855       || gcry_pk_algo_info (pk_algo, GCRYCTL_GET_ALGO_NSKEY, NULL, &nskey)
856       || !npkey || npkey >= nskey)
857     goto bad_seckey;
858
859   /* Check that the pubkey algo matches the one from the public key.  */
860   switch (canon_pk_algo (pk_algo))
861     {
862     case GCRY_PK_RSA:
863       if (!is_RSA (pk->pubkey_algo))
864         pk_algo = 0;  /* Does not match.  */
865       break;
866     case GCRY_PK_DSA:
867       if (!is_DSA (pk->pubkey_algo))
868         pk_algo = 0;  /* Does not match.  */
869       break;
870     case GCRY_PK_ELG:
871       if (!is_ELGAMAL (pk->pubkey_algo))
872         pk_algo = 0;  /* Does not match.  */
873       break;
874     case GCRY_PK_ECC:
875       if (pk->pubkey_algo == PUBKEY_ALGO_ECDSA)
876         ;
877       else if (pk->pubkey_algo == PUBKEY_ALGO_ECDH)
878         is_ecdh = 1;
879       else if (pk->pubkey_algo == PUBKEY_ALGO_EDDSA)
880         ;
881       else
882         pk_algo = 0;  /* Does not match.  */
883       /* For ECC we do not have the domain parameters thus fix our info.  */
884       npkey = 1;
885       nskey = 2;
886       break;
887     default:
888       pk_algo = 0;   /* Oops.  */
889       break;
890     }
891   if (!pk_algo)
892     {
893       err = gpg_error (GPG_ERR_PUBKEY_ALGO);
894       goto leave;
895     }
896
897   /* This check has to go after the ecc adjustments. */
898   if (nskey > PUBKEY_MAX_NSKEY)
899     goto bad_seckey;
900
901   /* Parse the key parameters.  */
902   gcry_sexp_release (list);
903   list = gcry_sexp_find_token (top_list, "skey", 0);
904   if (!list)
905     goto bad_seckey;
906   for (idx=0;;)
907     {
908       int is_enc;
909
910       value = gcry_sexp_nth_data (list, ++idx, &valuelen);
911       if (!value && skeyidx >= npkey)
912         break;  /* Ready.  */
913
914       /* Check for too many parameters.  Note that depending on the
915          protection mode and version number we may see less than NSKEY
916          (but at least NPKEY+1) parameters.  */
917       if (idx >= 2*nskey)
918         goto bad_seckey;
919       if (skeyidx >= DIM (skey)-1)
920         goto bad_seckey;
921
922       if (!value || valuelen != 1 || !(value[0] == '_' || value[0] == 'e'))
923         goto bad_seckey;
924       is_enc = (value[0] == 'e');
925       value = gcry_sexp_nth_data (list, ++idx, &valuelen);
926       if (!value || !valuelen)
927         goto bad_seckey;
928       if (is_enc)
929         {
930           void *p = xtrymalloc (valuelen);
931           if (!p)
932             goto outofmem;
933           memcpy (p, value, valuelen);
934           skey[skeyidx] = gcry_mpi_set_opaque (NULL, p, valuelen*8);
935           if (!skey[skeyidx])
936             goto outofmem;
937         }
938       else
939         {
940           if (gcry_mpi_scan (skey + skeyidx, GCRYMPI_FMT_STD,
941                              value, valuelen, NULL))
942             goto bad_seckey;
943         }
944       skeyidx++;
945     }
946   skey[skeyidx++] = NULL;
947
948   gcry_sexp_release (list); list = NULL;
949
950   /* We have no need for the CSUM value thus we don't parse it.  */
951   /* list = gcry_sexp_find_token (top_list, "csum", 0); */
952   /* if (list) */
953   /*   { */
954   /*     string = gcry_sexp_nth_string (list, 1); */
955   /*     if (!string) */
956   /*       goto bad_seckey; */
957   /*     desired_csum = strtoul (string, NULL, 10); */
958   /*     xfree (string); */
959   /*   } */
960   /* else */
961   /*   desired_csum = 0; */
962   /* gcry_sexp_release (list); list = NULL; */
963
964   /* Get the curve name if any,  */
965   list = gcry_sexp_find_token (top_list, "curve", 0);
966   if (list)
967     {
968       curve = gcry_sexp_nth_string (list, 1);
969       gcry_sexp_release (list); list = NULL;
970     }
971
972   gcry_sexp_release (top_list); top_list = NULL;
973
974   /* log_debug ("XXX is_v4=%d\n", is_v4); */
975   /* log_debug ("XXX pubkey_algo=%d\n", pubkey_algo); */
976   /* log_debug ("XXX is_protected=%d\n", is_protected); */
977   /* log_debug ("XXX protect_algo=%d\n", protect_algo); */
978   /* log_printhex ("XXX iv", iv, ivlen); */
979   /* log_debug ("XXX ivlen=%d\n", ivlen); */
980   /* log_debug ("XXX s2k_mode=%d\n", s2k_mode); */
981   /* log_debug ("XXX s2k_algo=%d\n", s2k_algo); */
982   /* log_printhex ("XXX s2k_salt", s2k_salt, sizeof s2k_salt); */
983   /* log_debug ("XXX s2k_count=%lu\n", (unsigned long)s2k_count); */
984   /* for (idx=0; skey[idx]; idx++) */
985   /*   { */
986   /*     int is_enc = gcry_mpi_get_flag (skey[idx], GCRYMPI_FLAG_OPAQUE); */
987   /*     log_info ("XXX skey[%d]%s:", idx, is_enc? " (enc)":""); */
988   /*     if (is_enc) */
989   /*       { */
990   /*         void *p; */
991   /*         unsigned int nbits; */
992   /*         p = gcry_mpi_get_opaque (skey[idx], &nbits); */
993   /*         log_printhex (NULL, p, (nbits+7)/8); */
994   /*       } */
995   /*     else */
996   /*       gcry_mpi_dump (skey[idx]); */
997   /*     log_printf ("\n"); */
998   /*   } */
999
1000   if (!is_v4 || is_protected != 2 )
1001     {
1002       /* We only support the v4 format and a SHA-1 checksum.  */
1003       err = gpg_error (GPG_ERR_NOT_IMPLEMENTED);
1004       goto leave;
1005     }
1006
1007   /* We need to change the received parameters for ECC algorithms.
1008      The transfer format has the curve name and the parameters
1009      separate.  We put them all into the SKEY array.  */
1010   if (canon_pk_algo (pk_algo) == GCRY_PK_ECC)
1011     {
1012       const char *oidstr;
1013
1014       /* Assert that all required parameters are available.  We also
1015          check that the array does not contain more parameters than
1016          needed (this was used by some beta versions of 2.1.  */
1017       if (!curve || !skey[0] || !skey[1] || skey[2])
1018         {
1019           err = gpg_error (GPG_ERR_INTERNAL);
1020           goto leave;
1021         }
1022
1023       oidstr = openpgp_curve_to_oid (curve, NULL);
1024       if (!oidstr)
1025         {
1026           log_error ("no OID known for curve '%s'\n", curve);
1027           err = gpg_error (GPG_ERR_UNKNOWN_CURVE);
1028           goto leave;
1029         }
1030       /* Put the curve's OID into the MPI array.  This requires
1031          that we shift Q and D.  For ECDH also insert the KDF parms. */
1032       if (is_ecdh)
1033         {
1034           skey[4] = NULL;
1035           skey[3] = skey[1];
1036           skey[2] = gcry_mpi_copy (pk->pkey[2]);
1037         }
1038       else
1039         {
1040           skey[3] = NULL;
1041           skey[2] = skey[1];
1042         }
1043       skey[1] = skey[0];
1044       skey[0] = NULL;
1045       err = openpgp_oid_from_str (oidstr, skey + 0);
1046       if (err)
1047         goto leave;
1048       /* Fixup the NPKEY and NSKEY to match OpenPGP reality.  */
1049       npkey = 2 + is_ecdh;
1050       nskey = 3 + is_ecdh;
1051
1052       /* for (idx=0; skey[idx]; idx++) */
1053       /*   { */
1054       /*     log_info ("YYY skey[%d]:", idx); */
1055       /*     if (gcry_mpi_get_flag (skey[idx], GCRYMPI_FLAG_OPAQUE)) */
1056       /*       { */
1057       /*         void *p; */
1058       /*         unsigned int nbits; */
1059       /*         p = gcry_mpi_get_opaque (skey[idx], &nbits); */
1060       /*         log_printhex (NULL, p, (nbits+7)/8); */
1061       /*       } */
1062       /*     else */
1063       /*       gcry_mpi_dump (skey[idx]); */
1064       /*     log_printf ("\n"); */
1065       /*   } */
1066     }
1067
1068   /* Do some sanity checks.  */
1069   if (s2k_count > 255)
1070     {
1071       /* We expect an already encoded S2K count.  */
1072       err = gpg_error (GPG_ERR_INV_DATA);
1073       goto leave;
1074     }
1075   err = openpgp_cipher_test_algo (protect_algo);
1076   if (err)
1077     goto leave;
1078   err = openpgp_md_test_algo (s2k_algo);
1079   if (err)
1080     goto leave;
1081
1082   /* Check that the public key parameters match.  Note that since
1083      Libgcrypt 1.5 gcry_mpi_cmp handles opaque MPI correctly.  */
1084   for (idx=0; idx < npkey; idx++)
1085     if (gcry_mpi_cmp (pk->pkey[idx], skey[idx]))
1086       {
1087         err = gpg_error (GPG_ERR_BAD_PUBKEY);
1088         goto leave;
1089       }
1090
1091   /* Check that the first secret key parameter in SKEY is encrypted
1092      and that there are no more secret key parameters.  The latter is
1093      guaranteed by the v4 packet format.  */
1094   if (!gcry_mpi_get_flag (skey[npkey], GCRYMPI_FLAG_OPAQUE))
1095     goto bad_seckey;
1096   if (npkey+1 < DIM (skey) && skey[npkey+1])
1097     goto bad_seckey;
1098
1099   /* Check that the secret key parameters in PK are all set to NULL. */
1100   for (idx=npkey; idx < nskey; idx++)
1101     if (pk->pkey[idx])
1102       goto bad_seckey;
1103
1104   /* Now build the protection info. */
1105   pk->seckey_info = ski = xtrycalloc (1, sizeof *ski);
1106   if (!ski)
1107     {
1108       err = gpg_error_from_syserror ();
1109       goto leave;
1110     }
1111
1112   ski->is_protected = 1;
1113   ski->sha1chk = 1;
1114   ski->algo = protect_algo;
1115   ski->s2k.mode = s2k_mode;
1116   ski->s2k.hash_algo = s2k_algo;
1117   log_assert (sizeof ski->s2k.salt == sizeof s2k_salt);
1118   memcpy (ski->s2k.salt, s2k_salt, sizeof s2k_salt);
1119   ski->s2k.count = s2k_count;
1120   log_assert (ivlen <= sizeof ski->iv);
1121   memcpy (ski->iv, iv, ivlen);
1122   ski->ivlen = ivlen;
1123
1124   /* Store the protected secret key parameter.  */
1125   pk->pkey[npkey] = skey[npkey];
1126   skey[npkey] = NULL;
1127
1128   /* That's it.  */
1129
1130  leave:
1131   gcry_free (curve);
1132   gcry_sexp_release (list);
1133   gcry_sexp_release (top_list);
1134   for (idx=0; idx < skeyidx; idx++)
1135     gcry_mpi_release (skey[idx]);
1136   return err;
1137
1138  bad_seckey:
1139   err = gpg_error (GPG_ERR_BAD_SECKEY);
1140   goto leave;
1141
1142  outofmem:
1143   err = gpg_error (GPG_ERR_ENOMEM);
1144   goto leave;
1145 }
1146
1147
1148 /* Print an "EXPORTED" status line.  PK is the primary public key.  */
1149 static void
1150 print_status_exported (PKT_public_key *pk)
1151 {
1152   char *hexfpr;
1153
1154   if (!is_status_enabled ())
1155     return;
1156
1157   hexfpr = hexfingerprint (pk, NULL, 0);
1158   write_status_text (STATUS_EXPORTED, hexfpr? hexfpr : "[?]");
1159   xfree (hexfpr);
1160 }
1161
1162
1163 /*
1164  * Receive a secret key from agent specified by HEXGRIP.
1165  *
1166  * Since the key data from the agent is encrypted, decrypt it using
1167  * CIPHERHD context.  Then, parse the decrypted key data into transfer
1168  * format, and put secret parameters into PK.
1169  *
1170  * If CLEARTEXT is 0, store the secret key material
1171  * passphrase-protected.  Otherwise, store secret key material in the
1172  * clear.
1173  *
1174  * CACHE_NONCE_ADDR is used to share nonce for multiple key retrievals.
1175  */
1176 gpg_error_t
1177 receive_seckey_from_agent (ctrl_t ctrl, gcry_cipher_hd_t cipherhd,
1178                            int cleartext,
1179                            char **cache_nonce_addr, const char *hexgrip,
1180                            PKT_public_key *pk)
1181 {
1182   gpg_error_t err = 0;
1183   unsigned char *wrappedkey = NULL;
1184   size_t wrappedkeylen;
1185   unsigned char *key = NULL;
1186   size_t keylen, realkeylen;
1187   gcry_sexp_t s_skey;
1188   char *prompt;
1189
1190   if (opt.verbose)
1191     log_info ("key %s: asking agent for the secret parts\n", hexgrip);
1192
1193   prompt = gpg_format_keydesc (ctrl, pk, FORMAT_KEYDESC_EXPORT,1);
1194   err = agent_export_key (ctrl, hexgrip, prompt, !cleartext, cache_nonce_addr,
1195                           &wrappedkey, &wrappedkeylen,
1196                           pk->keyid, pk->main_keyid, pk->pubkey_algo);
1197   xfree (prompt);
1198
1199   if (err)
1200     goto unwraperror;
1201   if (wrappedkeylen < 24)
1202     {
1203       err = gpg_error (GPG_ERR_INV_LENGTH);
1204       goto unwraperror;
1205     }
1206   keylen = wrappedkeylen - 8;
1207   key = xtrymalloc_secure (keylen);
1208   if (!key)
1209     {
1210       err = gpg_error_from_syserror ();
1211       goto unwraperror;
1212     }
1213   err = gcry_cipher_decrypt (cipherhd, key, keylen, wrappedkey, wrappedkeylen);
1214   if (err)
1215     goto unwraperror;
1216   realkeylen = gcry_sexp_canon_len (key, keylen, NULL, &err);
1217   if (!realkeylen)
1218     goto unwraperror; /* Invalid csexp.  */
1219
1220   err = gcry_sexp_sscan (&s_skey, NULL, key, realkeylen);
1221   if (!err)
1222     {
1223       if (cleartext)
1224         err = cleartext_secret_key_to_openpgp (s_skey, pk);
1225       else
1226         err = transfer_format_to_openpgp (s_skey, pk);
1227       gcry_sexp_release (s_skey);
1228     }
1229
1230  unwraperror:
1231   xfree (key);
1232   xfree (wrappedkey);
1233   if (err)
1234     {
1235       log_error ("key %s: error receiving key from agent:"
1236                  " %s%s\n", hexgrip, gpg_strerror (err),
1237                  gpg_err_code (err) == GPG_ERR_FULLY_CANCELED?
1238                  "":_(" - skipped"));
1239     }
1240   return err;
1241 }
1242
1243
1244 /* Write KEYBLOCK either to stdout or to the file set with the
1245  * --output option.  This is a simplified version of do_export_stream
1246  * which supports only a few export options.  */
1247 gpg_error_t
1248 write_keyblock_to_output (kbnode_t keyblock, int with_armor,
1249                           unsigned int options)
1250 {
1251   gpg_error_t err;
1252   const char *fname;
1253   iobuf_t out;
1254   kbnode_t node;
1255   armor_filter_context_t *afx = NULL;
1256   iobuf_t out_help = NULL;
1257   PKT_public_key *pk = NULL;
1258
1259   fname = opt.outfile? opt.outfile : "-";
1260   if (is_secured_filename (fname) )
1261     return gpg_error (GPG_ERR_EPERM);
1262
1263   out = iobuf_create (fname, 0);
1264   if (!out)
1265     {
1266       err = gpg_error_from_syserror ();
1267       log_error(_("can't create '%s': %s\n"), fname, gpg_strerror (err));
1268       return err;
1269     }
1270   if (opt.verbose)
1271     log_info (_("writing to '%s'\n"), iobuf_get_fname_nonnull (out));
1272
1273   if ((options & (EXPORT_PKA_FORMAT|EXPORT_DANE_FORMAT)))
1274     {
1275       with_armor = 0;
1276       out_help = iobuf_temp ();
1277     }
1278
1279   if (with_armor)
1280     {
1281       afx = new_armor_context ();
1282       afx->what = 1;
1283       push_armor_filter (afx, out);
1284     }
1285
1286   for (node = keyblock; node; node = node->next)
1287     {
1288       if (is_deleted_kbnode (node))
1289         continue;
1290       if (node->pkt->pkttype == PKT_RING_TRUST)
1291         continue; /* Skip - they should not be here anyway.  */
1292
1293       if (!pk && (node->pkt->pkttype == PKT_PUBLIC_KEY
1294                   || node->pkt->pkttype == PKT_SECRET_KEY))
1295         pk = node->pkt->pkt.public_key;
1296
1297       if ((options & EXPORT_BACKUP))
1298         err = build_packet_and_meta (out_help? out_help : out, node->pkt);
1299       else
1300         err = build_packet (out_help? out_help : out, node->pkt);
1301       if (err)
1302         {
1303           log_error ("build_packet(%d) failed: %s\n",
1304                      node->pkt->pkttype, gpg_strerror (err) );
1305           goto leave;
1306         }
1307     }
1308   err = 0;
1309
1310   if (out_help && pk)
1311     {
1312       const void *data;
1313       size_t datalen;
1314
1315       iobuf_flush_temp (out_help);
1316       data = iobuf_get_temp_buffer (out_help);
1317       datalen = iobuf_get_temp_length (out_help);
1318
1319       err = print_pka_or_dane_records (out,
1320                                        keyblock, pk, data, datalen,
1321                                        (options & EXPORT_PKA_FORMAT),
1322                                        (options & EXPORT_DANE_FORMAT));
1323     }
1324
1325  leave:
1326   if (err)
1327     iobuf_cancel (out);
1328   else
1329     iobuf_close (out);
1330   iobuf_cancel (out_help);
1331   release_armor_context (afx);
1332   return err;
1333 }
1334
1335
1336 /*
1337  * Apply the keep-uid filter to the keyblock.  The deleted nodes are
1338  * marked and thus the caller should call commit_kbnode afterwards.
1339  * KEYBLOCK must not have any blocks marked as deleted.
1340  */
1341 static void
1342 apply_keep_uid_filter (ctrl_t ctrl, kbnode_t keyblock, recsel_expr_t selector)
1343 {
1344   kbnode_t node;
1345   struct impex_filter_parm_s parm;
1346
1347   parm.ctrl = ctrl;
1348
1349   for (node = keyblock->next; node; node = node->next )
1350     {
1351       if (node->pkt->pkttype == PKT_USER_ID)
1352         {
1353           parm.node = node;
1354           if (!recsel_select (selector, impex_filter_getval, &parm))
1355             {
1356               /* log_debug ("keep-uid: deleting '%s'\n", */
1357               /*            node->pkt->pkt.user_id->name); */
1358               /* The UID packet and all following packets up to the
1359                * next UID or a subkey.  */
1360               delete_kbnode (node);
1361               for (; node->next
1362                      && node->next->pkt->pkttype != PKT_USER_ID
1363                      && node->next->pkt->pkttype != PKT_PUBLIC_SUBKEY
1364                      && node->next->pkt->pkttype != PKT_SECRET_SUBKEY ;
1365                    node = node->next)
1366                 delete_kbnode (node->next);
1367             }
1368           /* else */
1369           /*   log_debug ("keep-uid: keeping '%s'\n", */
1370           /*              node->pkt->pkt.user_id->name); */
1371         }
1372     }
1373 }
1374
1375
1376 /*
1377  * Apply the drop-subkey filter to the keyblock.  The deleted nodes are
1378  * marked and thus the caller should call commit_kbnode afterwards.
1379  * KEYBLOCK must not have any blocks marked as deleted.
1380  */
1381 static void
1382 apply_drop_subkey_filter (ctrl_t ctrl, kbnode_t keyblock,
1383                           recsel_expr_t selector)
1384 {
1385   kbnode_t node;
1386   struct impex_filter_parm_s parm;
1387
1388   parm.ctrl = ctrl;
1389
1390   for (node = keyblock->next; node; node = node->next )
1391     {
1392       if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY
1393           || node->pkt->pkttype == PKT_SECRET_SUBKEY)
1394         {
1395           parm.node = node;
1396           if (recsel_select (selector, impex_filter_getval, &parm))
1397             {
1398               /*log_debug ("drop-subkey: deleting a key\n");*/
1399               /* The subkey packet and all following packets up to the
1400                * next subkey.  */
1401               delete_kbnode (node);
1402               for (; node->next
1403                      && node->next->pkt->pkttype != PKT_PUBLIC_SUBKEY
1404                      && node->next->pkt->pkttype != PKT_SECRET_SUBKEY ;
1405                    node = node->next)
1406                 delete_kbnode (node->next);
1407             }
1408         }
1409     }
1410 }
1411
1412
1413 /* Print DANE or PKA records for all user IDs in KEYBLOCK to OUT.  The
1414  * data for the record is taken from (DATA,DATELEN).  PK is the public
1415  * key packet with the primary key. */
1416 static gpg_error_t
1417 print_pka_or_dane_records (iobuf_t out, kbnode_t keyblock, PKT_public_key *pk,
1418                            const void *data, size_t datalen,
1419                            int print_pka, int print_dane)
1420 {
1421   gpg_error_t err = 0;
1422   kbnode_t kbctx, node;
1423   PKT_user_id *uid;
1424   char *mbox = NULL;
1425   char hashbuf[32];
1426   char *hash = NULL;
1427   char *domain;
1428   const char *s;
1429   unsigned int len;
1430   estream_t fp = NULL;
1431   char *hexdata = NULL;
1432   char *hexfpr;
1433
1434   hexfpr = hexfingerprint (pk, NULL, 0);
1435   if (!hexfpr)
1436     {
1437       err = gpg_error_from_syserror ();
1438       goto leave;
1439     }
1440   hexdata = bin2hex (data, datalen, NULL);
1441   if (!hexdata)
1442     {
1443       err = gpg_error_from_syserror ();
1444       goto leave;
1445     }
1446   ascii_strlwr (hexdata);
1447   fp = es_fopenmem (0, "rw,samethread");
1448   if (!fp)
1449     {
1450       err = gpg_error_from_syserror ();
1451       goto leave;
1452     }
1453
1454   for (kbctx = NULL; (node = walk_kbnode (keyblock, &kbctx, 0));)
1455     {
1456       if (node->pkt->pkttype != PKT_USER_ID)
1457         continue;
1458       uid = node->pkt->pkt.user_id;
1459
1460       if (uid->flags.expired || uid->flags.revoked)
1461         continue;
1462
1463       xfree (mbox);
1464       mbox = mailbox_from_userid (uid->name, 0);
1465       if (!mbox)
1466         continue;
1467
1468       domain = strchr (mbox, '@');
1469       *domain++ = 0;
1470
1471       if (print_pka)
1472         {
1473           es_fprintf (fp, "$ORIGIN _pka.%s.\n; %s\n; ", domain, hexfpr);
1474           print_utf8_buffer (fp, uid->name, uid->len);
1475           es_putc ('\n', fp);
1476           gcry_md_hash_buffer (GCRY_MD_SHA1, hashbuf, mbox, strlen (mbox));
1477           xfree (hash);
1478           hash = zb32_encode (hashbuf, 8*20);
1479           if (!hash)
1480             {
1481               err = gpg_error_from_syserror ();
1482               goto leave;
1483             }
1484           len = strlen (hexfpr)/2;
1485           es_fprintf (fp, "%s TYPE37 \\# %u 0006 0000 00 %02X %s\n\n",
1486                       hash, 6 + len, len, hexfpr);
1487         }
1488
1489       if (print_dane && hexdata)
1490         {
1491           es_fprintf (fp, "$ORIGIN _openpgpkey.%s.\n; %s\n; ", domain, hexfpr);
1492           print_utf8_buffer (fp, uid->name, uid->len);
1493           es_putc ('\n', fp);
1494           gcry_md_hash_buffer (GCRY_MD_SHA256, hashbuf, mbox, strlen (mbox));
1495           xfree (hash);
1496           hash = bin2hex (hashbuf, 28, NULL);
1497           if (!hash)
1498             {
1499               err = gpg_error_from_syserror ();
1500               goto leave;
1501             }
1502           ascii_strlwr (hash);
1503           len = strlen (hexdata)/2;
1504           es_fprintf (fp, "%s TYPE61 \\# %u (\n", hash, len);
1505           for (s = hexdata; ;)
1506             {
1507               es_fprintf (fp, "\t%.64s\n", s);
1508               if (strlen (s) < 64)
1509                 break;
1510               s += 64;
1511             }
1512           es_fputs ("\t)\n\n", fp);
1513         }
1514     }
1515
1516   /* Make sure it is a string and write it.  */
1517   es_fputc (0, fp);
1518   {
1519     void *vp;
1520
1521     if (es_fclose_snatch (fp, &vp, NULL))
1522       {
1523         err = gpg_error_from_syserror ();
1524         goto leave;
1525       }
1526     fp = NULL;
1527     iobuf_writestr (out, vp);
1528     es_free (vp);
1529   }
1530   err = 0;
1531
1532  leave:
1533   xfree (hash);
1534   xfree (mbox);
1535   es_fclose (fp);
1536   xfree (hexdata);
1537   xfree (hexfpr);
1538   return err;
1539 }
1540
1541
1542 /* Helper for do_export_stream which writes one keyblock to OUT.  */
1543 static gpg_error_t
1544 do_export_one_keyblock (ctrl_t ctrl, kbnode_t keyblock, u32 *keyid,
1545                         iobuf_t out, int secret, unsigned int options,
1546                         export_stats_t stats, int *any,
1547                         KEYDB_SEARCH_DESC *desc, size_t ndesc,
1548                         size_t descindex, gcry_cipher_hd_t cipherhd)
1549 {
1550   gpg_error_t err = gpg_error (GPG_ERR_NOT_FOUND);
1551   char *cache_nonce = NULL;
1552   subkey_list_t subkey_list = NULL;  /* Track already processed subkeys. */
1553   int skip_until_subkey = 0;
1554   int cleartext = 0;
1555   char *hexgrip = NULL;
1556   char *serialno = NULL;
1557   PKT_public_key *pk;
1558   u32 subkidbuf[2], *subkid;
1559   kbnode_t kbctx, node;
1560
1561   /* NB: walk_kbnode skips packets marked as deleted.  */
1562   for (kbctx=NULL; (node = walk_kbnode (keyblock, &kbctx, 0)); )
1563     {
1564       if (skip_until_subkey)
1565         {
1566           if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
1567             skip_until_subkey = 0;
1568           else
1569             continue;
1570         }
1571
1572       /* We used to use comment packets, but not any longer.  In
1573        * case we still have comments on a key, strip them here
1574        * before we call build_packet(). */
1575       if (node->pkt->pkttype == PKT_COMMENT)
1576         continue;
1577
1578       /* Skip ring trust packets - they should not be here anyway.  */
1579       if (node->pkt->pkttype == PKT_RING_TRUST)
1580         continue;
1581
1582       /* If exact is set, then we only export what was requested
1583        * (plus the primary key, if the user didn't specifically
1584        * request it). */
1585       if (desc[descindex].exact && node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
1586         {
1587           if (!exact_subkey_match_p (desc+descindex, node))
1588             {
1589               /* Before skipping this subkey, check whether any
1590                * other description wants an exact match on a
1591                * subkey and include that subkey into the output
1592                * too.  Need to add this subkey to a list so that
1593                * it won't get processed a second time.
1594                *
1595                * So the first step here is to check that list and
1596                * skip in any case if the key is in that list.
1597                *
1598                * We need this whole mess because the import
1599                * function of GnuPG < 2.1 is not able to merge
1600                * secret keys and thus it is useless to output them
1601                * as two separate keys and have import merge them.
1602                */
1603               if (subkey_in_list_p (subkey_list, node))
1604                 skip_until_subkey = 1; /* Already processed this one. */
1605               else
1606                 {
1607                   size_t j;
1608
1609                   for (j=0; j < ndesc; j++)
1610                     if (j != descindex && desc[j].exact
1611                         && exact_subkey_match_p (desc+j, node))
1612                       break;
1613                   if (!(j < ndesc))
1614                     skip_until_subkey = 1; /* No other one matching. */
1615                 }
1616             }
1617
1618           if (skip_until_subkey)
1619             continue;
1620
1621           /* Mark this one as processed. */
1622           {
1623             subkey_list_t tmp = new_subkey_list_item (node);
1624             tmp->next = subkey_list;
1625             subkey_list = tmp;
1626           }
1627         }
1628
1629       if (node->pkt->pkttype == PKT_SIGNATURE)
1630         {
1631           /* Do not export packets which are marked as not
1632            * exportable.  */
1633           if (!(options & EXPORT_LOCAL_SIGS)
1634               && !node->pkt->pkt.signature->flags.exportable)
1635             continue; /* not exportable */
1636
1637           /* Do not export packets with a "sensitive" revocation key
1638            * unless the user wants us to.  Note that we do export
1639            * these when issuing the actual revocation (see revoke.c). */
1640           if (!(options & EXPORT_SENSITIVE_REVKEYS)
1641               && node->pkt->pkt.signature->revkey)
1642             {
1643               int i;
1644
1645               for (i = 0; i < node->pkt->pkt.signature->numrevkeys; i++)
1646                 if ((node->pkt->pkt.signature->revkey[i].class & 0x40))
1647                   break;
1648               if (i < node->pkt->pkt.signature->numrevkeys)
1649                 continue;
1650             }
1651         }
1652
1653       /* Don't export user ids (and attributes)?  This is not RFC-4880
1654        * compliant but we allow it anyway.  */
1655       if ((options & EXPORT_DROP_UIDS)
1656           && node->pkt->pkttype == PKT_USER_ID)
1657         {
1658           /* Skip until we get to something that is not a user id (or
1659            * attrib) or a signature on it.  */
1660           while (kbctx->next && kbctx->next->pkt->pkttype == PKT_SIGNATURE)
1661             kbctx = kbctx->next;
1662
1663           continue;
1664         }
1665
1666       /* Don't export attribs? */
1667       if (!(options & EXPORT_ATTRIBUTES)
1668           && node->pkt->pkttype == PKT_USER_ID
1669           && node->pkt->pkt.user_id->attrib_data)
1670         {
1671           /* Skip until we get to something that is not an attrib or a
1672            * signature on an attrib.  */
1673           while (kbctx->next && kbctx->next->pkt->pkttype == PKT_SIGNATURE)
1674             kbctx = kbctx->next;
1675
1676           continue;
1677         }
1678
1679       if (secret && (node->pkt->pkttype == PKT_PUBLIC_KEY
1680                      || node->pkt->pkttype == PKT_PUBLIC_SUBKEY))
1681         {
1682           pk = node->pkt->pkt.public_key;
1683           if (node->pkt->pkttype == PKT_PUBLIC_KEY)
1684             subkid = NULL;
1685           else
1686             {
1687               keyid_from_pk (pk, subkidbuf);
1688               subkid = subkidbuf;
1689             }
1690
1691           if (pk->seckey_info)
1692             {
1693               log_error ("key %s: oops: seckey_info already set"
1694                          " - skipped\n", keystr_with_sub (keyid, subkid));
1695               skip_until_subkey = 1;
1696               continue;
1697             }
1698
1699           xfree (hexgrip);
1700           err = hexkeygrip_from_pk (pk, &hexgrip);
1701           if (err)
1702             {
1703               log_error ("key %s: error computing keygrip: %s"
1704                          " - skipped\n", keystr_with_sub (keyid, subkid),
1705                          gpg_strerror (err));
1706               skip_until_subkey = 1;
1707               err = 0;
1708               continue;
1709             }
1710
1711           xfree (serialno);
1712           serialno = NULL;
1713           if (secret == 2 && node->pkt->pkttype == PKT_PUBLIC_KEY)
1714             {
1715               /* We are asked not to export the secret parts of the
1716                * primary key.  Make up an error code to create the
1717                * stub.  */
1718               err = GPG_ERR_NOT_FOUND;
1719             }
1720           else
1721             err = agent_get_keyinfo (ctrl, hexgrip, &serialno, &cleartext);
1722
1723           if ((!err && serialno)
1724               && secret == 2 && node->pkt->pkttype == PKT_PUBLIC_KEY)
1725             {
1726               /* It does not make sense to export a key with its
1727                * primary key on card using a non-key stub.  Thus we
1728                * skip those keys when used with --export-secret-subkeys. */
1729               log_info (_("key %s: key material on-card - skipped\n"),
1730                         keystr_with_sub (keyid, subkid));
1731               skip_until_subkey = 1;
1732             }
1733           else if (gpg_err_code (err) == GPG_ERR_NOT_FOUND
1734                    || (!err && serialno))
1735             {
1736               /* Create a key stub.  */
1737               struct seckey_info *ski;
1738               const char *s;
1739
1740               pk->seckey_info = ski = xtrycalloc (1, sizeof *ski);
1741               if (!ski)
1742                 {
1743                   err = gpg_error_from_syserror ();
1744                   goto leave;
1745                 }
1746
1747               ski->is_protected = 1;
1748               if (err)
1749                 ski->s2k.mode = 1001; /* GNU dummy (no secret key).  */
1750               else
1751                 {
1752                   ski->s2k.mode = 1002; /* GNU-divert-to-card.  */
1753                   for (s=serialno; sizeof (ski->ivlen) && *s && s[1];
1754                        ski->ivlen++, s += 2)
1755                     ski->iv[ski->ivlen] = xtoi_2 (s);
1756                 }
1757
1758               if ((options & EXPORT_BACKUP))
1759                 err = build_packet_and_meta (out, node->pkt);
1760               else
1761                 err = build_packet (out, node->pkt);
1762               if (!err && node->pkt->pkttype == PKT_PUBLIC_KEY)
1763                 {
1764                   stats->exported++;
1765                   print_status_exported (node->pkt->pkt.public_key);
1766                 }
1767             }
1768           else if (!err)
1769             {
1770               err = receive_seckey_from_agent (ctrl, cipherhd,
1771                                                cleartext, &cache_nonce,
1772                                                hexgrip, pk);
1773               if (err)
1774                 {
1775                   if (gpg_err_code (err) == GPG_ERR_FULLY_CANCELED)
1776                     goto leave;
1777                   skip_until_subkey = 1;
1778                   err = 0;
1779                 }
1780               else
1781                 {
1782                   if ((options & EXPORT_BACKUP))
1783                     err = build_packet_and_meta (out, node->pkt);
1784                   else
1785                     err = build_packet (out, node->pkt);
1786                   if (node->pkt->pkttype == PKT_PUBLIC_KEY)
1787                     {
1788                       stats->exported++;
1789                       print_status_exported (node->pkt->pkt.public_key);
1790                     }
1791                 }
1792             }
1793           else
1794             {
1795               log_error ("key %s: error getting keyinfo from agent: %s"
1796                          " - skipped\n", keystr_with_sub (keyid, subkid),
1797                              gpg_strerror (err));
1798               skip_until_subkey = 1;
1799               err = 0;
1800             }
1801
1802           xfree (pk->seckey_info);
1803           pk->seckey_info = NULL;
1804           {
1805             int i;
1806             for (i = pubkey_get_npkey (pk->pubkey_algo);
1807                  i < pubkey_get_nskey (pk->pubkey_algo); i++)
1808               {
1809                 gcry_mpi_release (pk->pkey[i]);
1810                 pk->pkey[i] = NULL;
1811               }
1812           }
1813         }
1814       else /* Not secret or common packets.  */
1815         {
1816           if ((options & EXPORT_BACKUP))
1817             err = build_packet_and_meta (out, node->pkt);
1818           else
1819             err = build_packet (out, node->pkt);
1820           if (!err && node->pkt->pkttype == PKT_PUBLIC_KEY)
1821             {
1822               stats->exported++;
1823               print_status_exported (node->pkt->pkt.public_key);
1824             }
1825         }
1826
1827       if (err)
1828         {
1829           log_error ("build_packet(%d) failed: %s\n",
1830                      node->pkt->pkttype, gpg_strerror (err));
1831           goto leave;
1832         }
1833
1834       if (!skip_until_subkey)
1835         *any = 1;
1836     }
1837
1838  leave:
1839   release_subkey_list (subkey_list);
1840   xfree (serialno);
1841   xfree (hexgrip);
1842   xfree (cache_nonce);
1843   return err;
1844 }
1845
1846
1847 /* Export the keys identified by the list of strings in USERS to the
1848    stream OUT.  If SECRET is false public keys will be exported.  With
1849    secret true secret keys will be exported; in this case 1 means the
1850    entire secret keyblock and 2 only the subkeys.  OPTIONS are the
1851    export options to apply.  If KEYBLOCK_OUT is not NULL, AND the exit
1852    code is zero, a pointer to the first keyblock found and exported
1853    will be stored at this address; no other keyblocks are exported in
1854    this case.  The caller must free the returned keyblock.  If any
1855    key has been exported true is stored at ANY. */
1856 static int
1857 do_export_stream (ctrl_t ctrl, iobuf_t out, strlist_t users, int secret,
1858                   kbnode_t *keyblock_out, unsigned int options,
1859                   export_stats_t stats, int *any)
1860 {
1861   gpg_error_t err = 0;
1862   PACKET pkt;
1863   kbnode_t keyblock = NULL;
1864   kbnode_t node;
1865   size_t ndesc, descindex;
1866   KEYDB_SEARCH_DESC *desc = NULL;
1867   KEYDB_HANDLE kdbhd;
1868   strlist_t sl;
1869   gcry_cipher_hd_t cipherhd = NULL;
1870   struct export_stats_s dummystats;
1871   iobuf_t out_help = NULL;
1872
1873   if (!stats)
1874     stats = &dummystats;
1875   *any = 0;
1876   init_packet (&pkt);
1877   kdbhd = keydb_new ();
1878   if (!kdbhd)
1879     return gpg_error_from_syserror ();
1880
1881   /* For the PKA and DANE format open a helper iobuf and for DANE
1882    * enforce some options.  */
1883   if ((options & (EXPORT_PKA_FORMAT | EXPORT_DANE_FORMAT)))
1884     {
1885       out_help = iobuf_temp ();
1886       if ((options & EXPORT_DANE_FORMAT))
1887         options |= EXPORT_MINIMAL | EXPORT_CLEAN;
1888     }
1889
1890   if (!users)
1891     {
1892       ndesc = 1;
1893       desc = xcalloc (ndesc, sizeof *desc);
1894       desc[0].mode = KEYDB_SEARCH_MODE_FIRST;
1895     }
1896   else
1897     {
1898       for (ndesc=0, sl=users; sl; sl = sl->next, ndesc++)
1899         ;
1900       desc = xmalloc ( ndesc * sizeof *desc);
1901
1902       for (ndesc=0, sl=users; sl; sl = sl->next)
1903         {
1904           if (!(err=classify_user_id (sl->d, desc+ndesc, 1)))
1905             ndesc++;
1906           else
1907             log_error (_("key \"%s\" not found: %s\n"),
1908                        sl->d, gpg_strerror (err));
1909         }
1910
1911       keydb_disable_caching (kdbhd);  /* We are looping the search.  */
1912
1913       /* It would be nice to see which of the given users did actually
1914          match one in the keyring.  To implement this we need to have
1915          a found flag for each entry in desc.  To set this flag we
1916          must check all those entries after a match to mark all
1917          matched one - currently we stop at the first match.  To do
1918          this we need an extra flag to enable this feature.  */
1919     }
1920
1921 #ifdef ENABLE_SELINUX_HACKS
1922   if (secret)
1923     {
1924       log_error (_("exporting secret keys not allowed\n"));
1925       err = gpg_error (GPG_ERR_NOT_SUPPORTED);
1926       goto leave;
1927     }
1928 #endif
1929
1930   /* For secret key export we need to setup a decryption context.  */
1931   if (secret)
1932     {
1933       void *kek = NULL;
1934       size_t keklen;
1935
1936       err = agent_keywrap_key (ctrl, 1, &kek, &keklen);
1937       if (err)
1938         {
1939           log_error ("error getting the KEK: %s\n", gpg_strerror (err));
1940           goto leave;
1941         }
1942
1943       /* Prepare a cipher context.  */
1944       err = gcry_cipher_open (&cipherhd, GCRY_CIPHER_AES128,
1945                               GCRY_CIPHER_MODE_AESWRAP, 0);
1946       if (!err)
1947         err = gcry_cipher_setkey (cipherhd, kek, keklen);
1948       if (err)
1949         {
1950           log_error ("error setting up an encryption context: %s\n",
1951                      gpg_strerror (err));
1952           goto leave;
1953         }
1954       xfree (kek);
1955       kek = NULL;
1956     }
1957
1958   for (;;)
1959     {
1960       u32 keyid[2];
1961       PKT_public_key *pk;
1962
1963       err = keydb_search (kdbhd, desc, ndesc, &descindex);
1964       if (!users)
1965         desc[0].mode = KEYDB_SEARCH_MODE_NEXT;
1966       if (err)
1967         break;
1968
1969       /* Read the keyblock. */
1970       release_kbnode (keyblock);
1971       keyblock = NULL;
1972       err = keydb_get_keyblock (kdbhd, &keyblock);
1973       if (err)
1974         {
1975           log_error (_("error reading keyblock: %s\n"), gpg_strerror (err));
1976           goto leave;
1977         }
1978
1979       node = find_kbnode (keyblock, PKT_PUBLIC_KEY);
1980       if (!node)
1981         {
1982           log_error ("public key packet not found in keyblock - skipped\n");
1983           continue;
1984         }
1985       stats->count++;
1986       setup_main_keyids (keyblock);  /* gpg_format_keydesc needs it.  */
1987       pk = node->pkt->pkt.public_key;
1988       keyid_from_pk (pk, keyid);
1989
1990       /* If a secret key export is required we need to check whether
1991          we have a secret key at all and if so create the seckey_info
1992          structure.  */
1993       if (secret)
1994         {
1995           if (agent_probe_any_secret_key (ctrl, keyblock))
1996             continue;  /* No secret key (neither primary nor subkey).  */
1997
1998           /* No v3 keys with GNU mode 1001. */
1999           if (secret == 2 && pk->version == 3)
2000             {
2001               log_info (_("key %s: PGP 2.x style key - skipped\n"),
2002                         keystr (keyid));
2003               continue;
2004             }
2005
2006           /* The agent does not yet allow export of v3 packets.  It is
2007              actually questionable whether we should allow them at
2008              all.  */
2009           if (pk->version == 3)
2010             {
2011               log_info ("key %s: PGP 2.x style key (v3) export "
2012                         "not yet supported - skipped\n", keystr (keyid));
2013               continue;
2014             }
2015           stats->secret_count++;
2016         }
2017
2018       /* Always do the cleaning on the public key part if requested.
2019        * A designated revocation is never stripped, even with
2020        * export-minimal set.  */
2021       if ((options & EXPORT_CLEAN))
2022         {
2023           merge_keys_and_selfsig (ctrl, keyblock);
2024           clean_all_uids (ctrl, keyblock, opt.verbose,
2025                           (options&EXPORT_MINIMAL), NULL, NULL);
2026           clean_all_subkeys (ctrl, keyblock, opt.verbose,
2027                              (options&EXPORT_MINIMAL)? KEY_CLEAN_ALL
2028                              /**/                    : KEY_CLEAN_AUTHENCR,
2029                              NULL, NULL);
2030           commit_kbnode (&keyblock);
2031         }
2032
2033       if (export_keep_uid)
2034         {
2035           commit_kbnode (&keyblock);
2036           apply_keep_uid_filter (ctrl, keyblock, export_keep_uid);
2037           commit_kbnode (&keyblock);
2038         }
2039
2040       if (export_drop_subkey)
2041         {
2042           commit_kbnode (&keyblock);
2043           apply_drop_subkey_filter (ctrl, keyblock, export_drop_subkey);
2044           commit_kbnode (&keyblock);
2045         }
2046
2047       /* And write it. */
2048       err = do_export_one_keyblock (ctrl, keyblock, keyid,
2049                                     out_help? out_help : out,
2050                                     secret, options, stats, any,
2051                                     desc, ndesc, descindex, cipherhd);
2052       if (err)
2053         break;
2054
2055       if (keyblock_out)
2056         {
2057           *keyblock_out = keyblock;
2058           break;
2059         }
2060
2061       if (out_help)
2062         {
2063           /* We want to write PKA or DANE records.  OUT_HELP has the
2064            * keyblock and we print a record for each uid to OUT. */
2065           const void *data;
2066           size_t datalen;
2067
2068           iobuf_flush_temp (out_help);
2069           data = iobuf_get_temp_buffer (out_help);
2070           datalen = iobuf_get_temp_length (out_help);
2071
2072           err = print_pka_or_dane_records (out,
2073                                            keyblock, pk, data, datalen,
2074                                            (options & EXPORT_PKA_FORMAT),
2075                                            (options & EXPORT_DANE_FORMAT));
2076           if (err)
2077             goto leave;
2078
2079           iobuf_close (out_help);
2080           out_help = iobuf_temp ();
2081         }
2082
2083     }
2084   if (gpg_err_code (err) == GPG_ERR_NOT_FOUND)
2085     err = 0;
2086
2087  leave:
2088   iobuf_cancel (out_help);
2089   gcry_cipher_close (cipherhd);
2090   xfree(desc);
2091   keydb_release (kdbhd);
2092   if (err || !keyblock_out)
2093     release_kbnode( keyblock );
2094   if( !*any )
2095     log_info(_("WARNING: nothing exported\n"));
2096   return err;
2097 }
2098
2099
2100
2101 \f
2102 static gpg_error_t
2103 key_to_sshblob (membuf_t *mb, const char *identifier, ...)
2104 {
2105   va_list arg_ptr;
2106   gpg_error_t err = 0;
2107   unsigned char nbuf[4];
2108   unsigned char *buf;
2109   size_t buflen;
2110   gcry_mpi_t a;
2111
2112   ulongtobuf (nbuf, (ulong)strlen (identifier));
2113   put_membuf (mb, nbuf, 4);
2114   put_membuf_str (mb, identifier);
2115   if (!strncmp (identifier, "ecdsa-sha2-", 11))
2116     {
2117       ulongtobuf (nbuf, (ulong)strlen (identifier+11));
2118       put_membuf (mb, nbuf, 4);
2119       put_membuf_str (mb, identifier+11);
2120     }
2121   va_start (arg_ptr, identifier);
2122   while ((a = va_arg (arg_ptr, gcry_mpi_t)))
2123     {
2124       err = gcry_mpi_aprint (GCRYMPI_FMT_SSH, &buf, &buflen, a);
2125       if (err)
2126         break;
2127       if (!strcmp (identifier, "ssh-ed25519")
2128           && buflen > 5 && buf[4] == 0x40)
2129         {
2130           /* We need to strip our 0x40 prefix.  */
2131           put_membuf (mb, "\x00\x00\x00\x20", 4);
2132           put_membuf (mb, buf+5, buflen-5);
2133         }
2134       else
2135         put_membuf (mb, buf, buflen);
2136       gcry_free (buf);
2137     }
2138   va_end (arg_ptr);
2139   return err;
2140 }
2141
2142 /* Export the key identified by USERID in the SSH public key format.
2143    The function exports the latest subkey with Authentication
2144    capability unless the '!' suffix is used to export a specific
2145    key.  */
2146 gpg_error_t
2147 export_ssh_key (ctrl_t ctrl, const char *userid)
2148 {
2149   gpg_error_t err;
2150   kbnode_t keyblock = NULL;
2151   KEYDB_SEARCH_DESC desc;
2152   u32 latest_date;
2153   u32 curtime = make_timestamp ();
2154   kbnode_t latest_key, node;
2155   PKT_public_key *pk;
2156   const char *identifier = NULL;
2157   membuf_t mb;
2158   estream_t fp = NULL;
2159   struct b64state b64_state;
2160   const char *fname = "-";
2161
2162   init_membuf (&mb, 4096);
2163
2164   /* We need to know whether the key has been specified using the
2165      exact syntax ('!' suffix).  Thus we need to run a
2166      classify_user_id on our own.  */
2167   err = classify_user_id (userid, &desc, 1);
2168
2169   /* Get the public key.  */
2170   if (!err)
2171     {
2172       getkey_ctx_t getkeyctx;
2173
2174       err = get_pubkey_byname (ctrl, &getkeyctx, NULL, userid, &keyblock,
2175                                NULL,
2176                                0  /* Only usable keys or given exact. */,
2177                                1  /* No AKL lookup.  */);
2178       if (!err)
2179         {
2180           err = getkey_next (ctrl, getkeyctx, NULL, NULL);
2181           if (!err)
2182             err = gpg_error (GPG_ERR_AMBIGUOUS_NAME);
2183           else if (gpg_err_code (err) == GPG_ERR_NO_PUBKEY)
2184             err = 0;
2185         }
2186       getkey_end (ctrl, getkeyctx);
2187     }
2188   if (err)
2189     {
2190       log_error (_("key \"%s\" not found: %s\n"), userid, gpg_strerror (err));
2191       return err;
2192     }
2193
2194   /* The finish_lookup code in getkey.c does not handle auth keys,
2195      thus we have to duplicate the code here to find the latest
2196      subkey.  However, if the key has been found using an exact match
2197      ('!' notation) we use that key without any further checks and
2198      even allow the use of the primary key. */
2199   latest_date = 0;
2200   latest_key = NULL;
2201   for (node = keyblock; node; node = node->next)
2202     {
2203       if ((node->pkt->pkttype == PKT_PUBLIC_SUBKEY
2204            || node->pkt->pkttype == PKT_PUBLIC_KEY)
2205           && node->pkt->pkt.public_key->flags.exact)
2206         {
2207           latest_key = node;
2208           break;
2209         }
2210     }
2211   if (!latest_key)
2212     {
2213       for (node = keyblock; node; node = node->next)
2214         {
2215           if (node->pkt->pkttype != PKT_PUBLIC_SUBKEY)
2216             continue;
2217
2218           pk = node->pkt->pkt.public_key;
2219           if (DBG_LOOKUP)
2220             log_debug ("\tchecking subkey %08lX\n",
2221                        (ulong) keyid_from_pk (pk, NULL));
2222           if (!(pk->pubkey_usage & PUBKEY_USAGE_AUTH))
2223             {
2224               if (DBG_LOOKUP)
2225                 log_debug ("\tsubkey not usable for authentication\n");
2226               continue;
2227             }
2228           if (!pk->flags.valid)
2229             {
2230               if (DBG_LOOKUP)
2231                 log_debug ("\tsubkey not valid\n");
2232               continue;
2233             }
2234           if (pk->flags.revoked)
2235             {
2236               if (DBG_LOOKUP)
2237                 log_debug ("\tsubkey has been revoked\n");
2238               continue;
2239             }
2240           if (pk->has_expired)
2241             {
2242               if (DBG_LOOKUP)
2243                 log_debug ("\tsubkey has expired\n");
2244               continue;
2245             }
2246           if (pk->timestamp > curtime && !opt.ignore_valid_from)
2247             {
2248               if (DBG_LOOKUP)
2249                 log_debug ("\tsubkey not yet valid\n");
2250               continue;
2251             }
2252           if (DBG_LOOKUP)
2253             log_debug ("\tsubkey might be fine\n");
2254           /* In case a key has a timestamp of 0 set, we make sure that it
2255              is used.  A better change would be to compare ">=" but that
2256              might also change the selected keys and is as such a more
2257              intrusive change.  */
2258           if (pk->timestamp > latest_date || (!pk->timestamp && !latest_date))
2259             {
2260               latest_date = pk->timestamp;
2261               latest_key = node;
2262             }
2263         }
2264
2265       /* If no subkey was suitable check the primary key.  */
2266       if (!latest_key
2267           && (node = keyblock) && node->pkt->pkttype == PKT_PUBLIC_KEY)
2268         {
2269           pk = node->pkt->pkt.public_key;
2270           if (DBG_LOOKUP)
2271             log_debug ("\tchecking primary key %08lX\n",
2272                        (ulong) keyid_from_pk (pk, NULL));
2273           if (!(pk->pubkey_usage & PUBKEY_USAGE_AUTH))
2274             {
2275               if (DBG_LOOKUP)
2276                 log_debug ("\tprimary key not usable for authentication\n");
2277             }
2278           else if (!pk->flags.valid)
2279             {
2280               if (DBG_LOOKUP)
2281                 log_debug ("\tprimary key not valid\n");
2282             }
2283           else if (pk->flags.revoked)
2284             {
2285               if (DBG_LOOKUP)
2286                 log_debug ("\tprimary key has been revoked\n");
2287             }
2288           else if (pk->has_expired)
2289             {
2290               if (DBG_LOOKUP)
2291                 log_debug ("\tprimary key has expired\n");
2292             }
2293           else if (pk->timestamp > curtime && !opt.ignore_valid_from)
2294             {
2295               if (DBG_LOOKUP)
2296                 log_debug ("\tprimary key not yet valid\n");
2297             }
2298           else
2299             {
2300               if (DBG_LOOKUP)
2301                 log_debug ("\tprimary key is fine\n");
2302               latest_date = pk->timestamp;
2303               latest_key = node;
2304             }
2305         }
2306     }
2307
2308   if (!latest_key)
2309     {
2310       err = gpg_error (GPG_ERR_UNUSABLE_PUBKEY);
2311       log_error (_("key \"%s\" not found: %s\n"), userid, gpg_strerror (err));
2312       goto leave;
2313     }
2314
2315   pk = latest_key->pkt->pkt.public_key;
2316   if (DBG_LOOKUP)
2317     log_debug ("\tusing key %08lX\n", (ulong) keyid_from_pk (pk, NULL));
2318
2319   switch (pk->pubkey_algo)
2320     {
2321     case PUBKEY_ALGO_DSA:
2322       identifier = "ssh-dss";
2323       err = key_to_sshblob (&mb, identifier,
2324                             pk->pkey[0], pk->pkey[1], pk->pkey[2], pk->pkey[3],
2325                             NULL);
2326       break;
2327
2328     case PUBKEY_ALGO_RSA:
2329     case PUBKEY_ALGO_RSA_S:
2330       identifier = "ssh-rsa";
2331       err = key_to_sshblob (&mb, identifier, pk->pkey[1], pk->pkey[0], NULL);
2332       break;
2333
2334     case PUBKEY_ALGO_ECDSA:
2335       {
2336         char *curveoid;
2337         const char *curve;
2338
2339         curveoid = openpgp_oid_to_str (pk->pkey[0]);
2340         if (!curveoid)
2341           err = gpg_error_from_syserror ();
2342         else if (!(curve = openpgp_oid_to_curve (curveoid, 0)))
2343           err = gpg_error (GPG_ERR_UNKNOWN_CURVE);
2344         else
2345           {
2346             if (!strcmp (curve, "nistp256"))
2347               identifier = "ecdsa-sha2-nistp256";
2348             else if (!strcmp (curve, "nistp384"))
2349               identifier = "ecdsa-sha2-nistp384";
2350             else if (!strcmp (curve, "nistp521"))
2351               identifier = "ecdsa-sha2-nistp521";
2352
2353             if (!identifier)
2354               err = gpg_error (GPG_ERR_UNKNOWN_CURVE);
2355             else
2356               err = key_to_sshblob (&mb, identifier, pk->pkey[1], NULL);
2357           }
2358         xfree (curveoid);
2359       }
2360       break;
2361
2362     case PUBKEY_ALGO_EDDSA:
2363       if (!openpgp_oid_is_ed25519 (pk->pkey[0]))
2364         err = gpg_error (GPG_ERR_UNKNOWN_CURVE);
2365       else
2366         {
2367           identifier = "ssh-ed25519";
2368           err = key_to_sshblob (&mb, identifier, pk->pkey[1], NULL);
2369         }
2370       break;
2371
2372     case PUBKEY_ALGO_ELGAMAL_E:
2373     case PUBKEY_ALGO_ELGAMAL:
2374       err = gpg_error (GPG_ERR_UNUSABLE_PUBKEY);
2375       break;
2376
2377     default:
2378       err = GPG_ERR_PUBKEY_ALGO;
2379       break;
2380     }
2381
2382   if (!identifier)
2383     goto leave;
2384
2385   if (opt.outfile && *opt.outfile && strcmp (opt.outfile, "-"))
2386     fp = es_fopen ((fname = opt.outfile), "w");
2387   else
2388     fp = es_stdout;
2389   if (!fp)
2390     {
2391       err = gpg_error_from_syserror ();
2392       log_error (_("error creating '%s': %s\n"), fname, gpg_strerror (err));
2393       goto leave;
2394     }
2395
2396   es_fprintf (fp, "%s ", identifier);
2397   err = b64enc_start_es (&b64_state, fp, "");
2398   if (!err)
2399     {
2400       void *blob;
2401       size_t bloblen;
2402
2403       blob = get_membuf (&mb, &bloblen);
2404       if (blob)
2405         {
2406           err = b64enc_write (&b64_state, blob, bloblen);
2407           xfree (blob);
2408           if (err)
2409             goto leave;
2410         }
2411       err = b64enc_finish (&b64_state);
2412     }
2413   if (err)
2414     goto leave;
2415   es_fprintf (fp, " openpgp:0x%08lX\n", (ulong)keyid_from_pk (pk, NULL));
2416
2417   if (es_ferror (fp))
2418     err = gpg_error_from_syserror ();
2419   else
2420     {
2421       if (es_fclose (fp))
2422         err = gpg_error_from_syserror ();
2423       fp = NULL;
2424     }
2425
2426   if (err)
2427     log_error (_("error writing '%s': %s\n"), fname, gpg_strerror (err));
2428
2429  leave:
2430   es_fclose (fp);
2431   xfree (get_membuf (&mb, NULL));
2432   release_kbnode (keyblock);
2433   return err;
2434 }