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