gpg: Support ECDSA keys with --export-ssh-key.
[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 #include <assert.h>
28
29 #include "gpg.h"
30 #include "options.h"
31 #include "packet.h"
32 #include "status.h"
33 #include "keydb.h"
34 #include "util.h"
35 #include "main.h"
36 #include "i18n.h"
37 #include "membuf.h"
38 #include "host2net.h"
39 #include "trustdb.h"
40 #include "call-agent.h"
41
42 /* An object to keep track of subkeys. */
43 struct subkey_list_s
44 {
45   struct subkey_list_s *next;
46   u32 kid[2];
47 };
48 typedef struct subkey_list_s *subkey_list_t;
49
50
51 /* An object to track statistics for export operations.  */
52 struct export_stats_s
53 {
54   ulong count;            /* Number of processed keys.        */
55   ulong secret_count;     /* Number of secret keys seen.      */
56   ulong exported;         /* Number of actual exported keys.  */
57 };
58
59
60 /* Local prototypes.  */
61 static int do_export (ctrl_t ctrl, strlist_t users, int secret,
62                       unsigned int options, export_stats_t stats);
63 static int do_export_stream (ctrl_t ctrl, iobuf_t out,
64                              strlist_t users, int secret,
65                              kbnode_t *keyblock_out, unsigned int options,
66                              export_stats_t stats, int *any);
67
68 \f
69
70
71 /* Option parser for export options.  See parse_options fro
72    details.  */
73 int
74 parse_export_options(char *str,unsigned int *options,int noisy)
75 {
76   struct parse_options export_opts[]=
77     {
78       {"export-local-sigs",EXPORT_LOCAL_SIGS,NULL,
79        N_("export signatures that are marked as local-only")},
80       {"export-attributes",EXPORT_ATTRIBUTES,NULL,
81        N_("export attribute user IDs (generally photo IDs)")},
82       {"export-sensitive-revkeys",EXPORT_SENSITIVE_REVKEYS,NULL,
83        N_("export revocation keys marked as \"sensitive\"")},
84       {"export-clean",EXPORT_CLEAN,NULL,
85        N_("remove unusable parts from key during export")},
86       {"export-minimal",EXPORT_MINIMAL|EXPORT_CLEAN,NULL,
87        N_("remove as much as possible from key during export")},
88       /* Aliases for backward compatibility */
89       {"include-local-sigs",EXPORT_LOCAL_SIGS,NULL,NULL},
90       {"include-attributes",EXPORT_ATTRIBUTES,NULL,NULL},
91       {"include-sensitive-revkeys",EXPORT_SENSITIVE_REVKEYS,NULL,NULL},
92       /* dummy */
93       {"export-unusable-sigs",0,NULL,NULL},
94       {"export-clean-sigs",0,NULL,NULL},
95       {"export-clean-uids",0,NULL,NULL},
96       {NULL,0,NULL,NULL}
97       /* add tags for include revoked and disabled? */
98     };
99
100   return parse_options(str,options,export_opts,noisy);
101 }
102
103
104 /* Create a new export stats object initialized to zero.  On error
105    returns NULL and sets ERRNO.  */
106 export_stats_t
107 export_new_stats (void)
108 {
109   export_stats_t stats;
110
111   return xtrycalloc (1, sizeof *stats);
112 }
113
114
115 /* Release an export stats object.  */
116 void
117 export_release_stats (export_stats_t stats)
118 {
119   xfree (stats);
120 }
121
122
123 /* Print export statistics using the status interface.  */
124 void
125 export_print_stats (export_stats_t stats)
126 {
127   if (!stats)
128     return;
129
130   if (is_status_enabled ())
131     {
132       char buf[15*20];
133
134       snprintf (buf, sizeof buf, "%lu %lu %lu",
135                 stats->count,
136                 stats->secret_count,
137                 stats->exported );
138       write_status_text (STATUS_EXPORT_RES, buf);
139     }
140 }
141
142
143 /*
144  * Export public keys (to stdout or to --output FILE).
145  *
146  * Depending on opt.armor the output is armored.  OPTIONS are defined
147  * in main.h.  If USERS is NULL, all keys will be exported.  STATS is
148  * either an export stats object for update or NULL.
149  *
150  * This function is the core of "gpg --export".
151  */
152 int
153 export_pubkeys (ctrl_t ctrl, strlist_t users, unsigned int options,
154                 export_stats_t stats)
155 {
156   return do_export (ctrl, users, 0, options, stats);
157 }
158
159
160 /*
161  * Export secret keys (to stdout or to --output FILE).
162  *
163  * Depending on opt.armor the output is armored.  If USERS is NULL,
164  * all secret keys will be exported.  STATS is either an export stats
165  * object for update or NULL.
166  *
167  * This function is the core of "gpg --export-secret-keys".
168  */
169 int
170 export_seckeys (ctrl_t ctrl, strlist_t users, export_stats_t stats)
171 {
172   return do_export (ctrl, users, 1, 0, stats);
173 }
174
175
176 /*
177  * Export secret sub keys (to stdout or to --output FILE).
178  *
179  * This is the same as export_seckeys but replaces the primary key by
180  * a stub key.  Depending on opt.armor the output is armored.  If
181  * USERS is NULL, all secret subkeys will be exported.  STATS is
182  * either an export stats object for update or NULL.
183  *
184  * This function is the core of "gpg --export-secret-subkeys".
185  */
186 int
187 export_secsubkeys (ctrl_t ctrl, strlist_t users, export_stats_t stats)
188 {
189   return do_export (ctrl, users, 2, 0, stats);
190 }
191
192
193 /*
194  * Export a single key into a memory buffer.  STATS is either an
195  * export stats object for update or NULL.
196  */
197 gpg_error_t
198 export_pubkey_buffer (ctrl_t ctrl, const char *keyspec, unsigned int options,
199                       export_stats_t stats,
200                       kbnode_t *r_keyblock, void **r_data, size_t *r_datalen)
201 {
202   gpg_error_t err;
203   iobuf_t iobuf;
204   int any;
205   strlist_t helplist;
206
207   *r_keyblock = NULL;
208   *r_data = NULL;
209   *r_datalen = 0;
210
211   helplist = NULL;
212   if (!add_to_strlist_try (&helplist, keyspec))
213     return gpg_error_from_syserror ();
214
215   iobuf = iobuf_temp ();
216   err = do_export_stream (ctrl, iobuf, helplist, 0, r_keyblock, options,
217                           stats, &any);
218   if (!err && !any)
219     err = gpg_error (GPG_ERR_NOT_FOUND);
220   if (!err)
221     {
222       const void *src;
223       size_t datalen;
224
225       iobuf_flush_temp (iobuf);
226       src = iobuf_get_temp_buffer (iobuf);
227       datalen = iobuf_get_temp_length (iobuf);
228       if (!datalen)
229         err = gpg_error (GPG_ERR_NO_PUBKEY);
230       else if (!(*r_data = xtrymalloc (datalen)))
231         err = gpg_error_from_syserror ();
232       else
233         {
234           memcpy (*r_data, src, datalen);
235           *r_datalen = datalen;
236         }
237     }
238   iobuf_close (iobuf);
239   free_strlist (helplist);
240   if (err && *r_keyblock)
241     {
242       release_kbnode (*r_keyblock);
243       *r_keyblock = NULL;
244     }
245   return err;
246 }
247
248
249 /* Export the keys identified by the list of strings in USERS.  If
250    Secret is false public keys will be exported.  With secret true
251    secret keys will be exported; in this case 1 means the entire
252    secret keyblock and 2 only the subkeys.  OPTIONS are the export
253    options to apply.  */
254 static int
255 do_export (ctrl_t ctrl, strlist_t users, int secret, unsigned int options,
256            export_stats_t stats)
257 {
258   IOBUF out = NULL;
259   int any, rc;
260   armor_filter_context_t *afx = NULL;
261   compress_filter_context_t zfx;
262
263   memset( &zfx, 0, sizeof zfx);
264
265   rc = open_outfile (-1, NULL, 0, !!secret, &out );
266   if (rc)
267     return rc;
268
269   if ( opt.armor )
270     {
271       afx = new_armor_context ();
272       afx->what = secret? 5 : 1;
273       push_armor_filter (afx, out);
274     }
275
276   rc = do_export_stream (ctrl, out, users, secret, NULL, options, stats, &any);
277
278   if ( rc || !any )
279     iobuf_cancel (out);
280   else
281     iobuf_close (out);
282   release_armor_context (afx);
283   return rc;
284 }
285
286
287
288 /* Release an entire subkey list. */
289 static void
290 release_subkey_list (subkey_list_t list)
291 {
292   while (list)
293     {
294       subkey_list_t tmp = list->next;;
295       xfree (list);
296       list = tmp;
297     }
298 }
299
300
301 /* Returns true if NODE is a subkey and contained in LIST. */
302 static int
303 subkey_in_list_p (subkey_list_t list, KBNODE node)
304 {
305   if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY
306       || node->pkt->pkttype == PKT_SECRET_SUBKEY )
307     {
308       u32 kid[2];
309
310       keyid_from_pk (node->pkt->pkt.public_key, kid);
311
312       for (; list; list = list->next)
313         if (list->kid[0] == kid[0] && list->kid[1] == kid[1])
314           return 1;
315     }
316   return 0;
317 }
318
319 /* Allocate a new subkey list item from NODE. */
320 static subkey_list_t
321 new_subkey_list_item (KBNODE node)
322 {
323   subkey_list_t list = xcalloc (1, sizeof *list);
324
325   if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY
326       || node->pkt->pkttype == PKT_SECRET_SUBKEY)
327     keyid_from_pk (node->pkt->pkt.public_key, list->kid);
328
329   return list;
330 }
331
332
333 /* Helper function to check whether the subkey at NODE actually
334    matches the description at DESC.  The function returns true if the
335    key under question has been specified by an exact specification
336    (keyID or fingerprint) and does match the one at NODE.  It is
337    assumed that the packet at NODE is either a public or secret
338    subkey. */
339 static int
340 exact_subkey_match_p (KEYDB_SEARCH_DESC *desc, KBNODE node)
341 {
342   u32 kid[2];
343   byte fpr[MAX_FINGERPRINT_LEN];
344   size_t fprlen;
345   int result = 0;
346
347   switch(desc->mode)
348     {
349     case KEYDB_SEARCH_MODE_SHORT_KID:
350     case KEYDB_SEARCH_MODE_LONG_KID:
351       keyid_from_pk (node->pkt->pkt.public_key, kid);
352       break;
353
354     case KEYDB_SEARCH_MODE_FPR16:
355     case KEYDB_SEARCH_MODE_FPR20:
356     case KEYDB_SEARCH_MODE_FPR:
357       fingerprint_from_pk (node->pkt->pkt.public_key, fpr,&fprlen);
358       break;
359
360     default:
361       break;
362     }
363
364   switch(desc->mode)
365     {
366     case KEYDB_SEARCH_MODE_SHORT_KID:
367       if (desc->u.kid[1] == kid[1])
368         result = 1;
369       break;
370
371     case KEYDB_SEARCH_MODE_LONG_KID:
372       if (desc->u.kid[0] == kid[0] && desc->u.kid[1] == kid[1])
373         result = 1;
374       break;
375
376     case KEYDB_SEARCH_MODE_FPR16:
377       if (!memcmp (desc->u.fpr, fpr, 16))
378         result = 1;
379       break;
380
381     case KEYDB_SEARCH_MODE_FPR20:
382     case KEYDB_SEARCH_MODE_FPR:
383       if (!memcmp (desc->u.fpr, fpr, 20))
384         result = 1;
385       break;
386
387     default:
388       break;
389     }
390
391   return result;
392 }
393
394
395 /* Return a canonicalized public key algoithms.  This is used to
396    compare different flavors of algorithms (e.g. ELG and ELG_E are
397    considered the same).  */
398 static enum gcry_pk_algos
399 canon_pk_algo (enum gcry_pk_algos algo)
400 {
401   switch (algo)
402     {
403     case GCRY_PK_RSA:
404     case GCRY_PK_RSA_E:
405     case GCRY_PK_RSA_S: return GCRY_PK_RSA;
406     case GCRY_PK_ELG:
407     case GCRY_PK_ELG_E: return GCRY_PK_ELG;
408     case GCRY_PK_ECC:
409     case GCRY_PK_ECDSA:
410     case GCRY_PK_ECDH: return GCRY_PK_ECC;
411     default: return algo;
412     }
413 }
414
415
416 /* Use the key transfer format given in S_PGP to create the secinfo
417    structure in PK and change the parameter array in PK to include the
418    secret parameters.  */
419 static gpg_error_t
420 transfer_format_to_openpgp (gcry_sexp_t s_pgp, PKT_public_key *pk)
421 {
422   gpg_error_t err;
423   gcry_sexp_t top_list;
424   gcry_sexp_t list = NULL;
425   char *curve = NULL;
426   const char *value;
427   size_t valuelen;
428   char *string;
429   int  idx;
430   int  is_v4, is_protected;
431   enum gcry_pk_algos pk_algo;
432   int  protect_algo = 0;
433   char iv[16];
434   int  ivlen = 0;
435   int  s2k_mode = 0;
436   int  s2k_algo = 0;
437   byte s2k_salt[8];
438   u32  s2k_count = 0;
439   int  is_ecdh = 0;
440   size_t npkey, nskey;
441   gcry_mpi_t skey[10];  /* We support up to 9 parameters.  */
442   int skeyidx = 0;
443   struct seckey_info *ski;
444
445   /* gcry_log_debugsxp ("transferkey", s_pgp); */
446   top_list = gcry_sexp_find_token (s_pgp, "openpgp-private-key", 0);
447   if (!top_list)
448     goto bad_seckey;
449
450   list = gcry_sexp_find_token (top_list, "version", 0);
451   if (!list)
452     goto bad_seckey;
453   value = gcry_sexp_nth_data (list, 1, &valuelen);
454   if (!value || valuelen != 1 || !(value[0] == '3' || value[0] == '4'))
455     goto bad_seckey;
456   is_v4 = (value[0] == '4');
457
458   gcry_sexp_release (list);
459   list = gcry_sexp_find_token (top_list, "protection", 0);
460   if (!list)
461     goto bad_seckey;
462   value = gcry_sexp_nth_data (list, 1, &valuelen);
463   if (!value)
464     goto bad_seckey;
465   if (valuelen == 4 && !memcmp (value, "sha1", 4))
466     is_protected = 2;
467   else if (valuelen == 3 && !memcmp (value, "sum", 3))
468     is_protected = 1;
469   else if (valuelen == 4 && !memcmp (value, "none", 4))
470     is_protected = 0;
471   else
472     goto bad_seckey;
473   if (is_protected)
474     {
475       string = gcry_sexp_nth_string (list, 2);
476       if (!string)
477         goto bad_seckey;
478       protect_algo = gcry_cipher_map_name (string);
479       xfree (string);
480
481       value = gcry_sexp_nth_data (list, 3, &valuelen);
482       if (!value || !valuelen || valuelen > sizeof iv)
483         goto bad_seckey;
484       memcpy (iv, value, valuelen);
485       ivlen = valuelen;
486
487       string = gcry_sexp_nth_string (list, 4);
488       if (!string)
489         goto bad_seckey;
490       s2k_mode = strtol (string, NULL, 10);
491       xfree (string);
492
493       string = gcry_sexp_nth_string (list, 5);
494       if (!string)
495         goto bad_seckey;
496       s2k_algo = gcry_md_map_name (string);
497       xfree (string);
498
499       value = gcry_sexp_nth_data (list, 6, &valuelen);
500       if (!value || !valuelen || valuelen > sizeof s2k_salt)
501         goto bad_seckey;
502       memcpy (s2k_salt, value, valuelen);
503
504       string = gcry_sexp_nth_string (list, 7);
505       if (!string)
506         goto bad_seckey;
507       s2k_count = strtoul (string, NULL, 10);
508       xfree (string);
509     }
510
511   /* Parse the gcrypt PK algo and check that it is okay.  */
512   gcry_sexp_release (list);
513   list = gcry_sexp_find_token (top_list, "algo", 0);
514   if (!list)
515     goto bad_seckey;
516   string = gcry_sexp_nth_string (list, 1);
517   if (!string)
518     goto bad_seckey;
519   pk_algo = gcry_pk_map_name (string);
520   xfree (string); string = NULL;
521   if (gcry_pk_algo_info (pk_algo, GCRYCTL_GET_ALGO_NPKEY, NULL, &npkey)
522       || gcry_pk_algo_info (pk_algo, GCRYCTL_GET_ALGO_NSKEY, NULL, &nskey)
523       || !npkey || npkey >= nskey)
524     goto bad_seckey;
525
526   /* Check that the pubkey algo matches the one from the public key.  */
527   switch (canon_pk_algo (pk_algo))
528     {
529     case GCRY_PK_RSA:
530       if (!is_RSA (pk->pubkey_algo))
531         pk_algo = 0;  /* Does not match.  */
532       break;
533     case GCRY_PK_DSA:
534       if (!is_DSA (pk->pubkey_algo))
535         pk_algo = 0;  /* Does not match.  */
536       break;
537     case GCRY_PK_ELG:
538       if (!is_ELGAMAL (pk->pubkey_algo))
539         pk_algo = 0;  /* Does not match.  */
540       break;
541     case GCRY_PK_ECC:
542       if (pk->pubkey_algo == PUBKEY_ALGO_ECDSA)
543         ;
544       else if (pk->pubkey_algo == PUBKEY_ALGO_ECDH)
545         is_ecdh = 1;
546       else if (pk->pubkey_algo == PUBKEY_ALGO_EDDSA)
547         ;
548       else
549         pk_algo = 0;  /* Does not match.  */
550       /* For ECC we do not have the domain parameters thus fix our info.  */
551       npkey = 1;
552       nskey = 2;
553       break;
554     default:
555       pk_algo = 0;   /* Oops.  */
556       break;
557     }
558   if (!pk_algo)
559     {
560       err = gpg_error (GPG_ERR_PUBKEY_ALGO);
561       goto leave;
562     }
563
564   /* This check has to go after the ecc adjustments. */
565   if (nskey > PUBKEY_MAX_NSKEY)
566     goto bad_seckey;
567
568   /* Parse the key parameters.  */
569   gcry_sexp_release (list);
570   list = gcry_sexp_find_token (top_list, "skey", 0);
571   if (!list)
572     goto bad_seckey;
573   for (idx=0;;)
574     {
575       int is_enc;
576
577       value = gcry_sexp_nth_data (list, ++idx, &valuelen);
578       if (!value && skeyidx >= npkey)
579         break;  /* Ready.  */
580
581       /* Check for too many parameters.  Note that depending on the
582          protection mode and version number we may see less than NSKEY
583          (but at least NPKEY+1) parameters.  */
584       if (idx >= 2*nskey)
585         goto bad_seckey;
586       if (skeyidx >= DIM (skey)-1)
587         goto bad_seckey;
588
589       if (!value || valuelen != 1 || !(value[0] == '_' || value[0] == 'e'))
590         goto bad_seckey;
591       is_enc = (value[0] == 'e');
592       value = gcry_sexp_nth_data (list, ++idx, &valuelen);
593       if (!value || !valuelen)
594         goto bad_seckey;
595       if (is_enc)
596         {
597           void *p = xtrymalloc (valuelen);
598           if (!p)
599             goto outofmem;
600           memcpy (p, value, valuelen);
601           skey[skeyidx] = gcry_mpi_set_opaque (NULL, p, valuelen*8);
602           if (!skey[skeyidx])
603             goto outofmem;
604         }
605       else
606         {
607           if (gcry_mpi_scan (skey + skeyidx, GCRYMPI_FMT_STD,
608                              value, valuelen, NULL))
609             goto bad_seckey;
610         }
611       skeyidx++;
612     }
613   skey[skeyidx++] = NULL;
614
615   gcry_sexp_release (list); list = NULL;
616
617   /* We have no need for the CSUM value thus we don't parse it.  */
618   /* list = gcry_sexp_find_token (top_list, "csum", 0); */
619   /* if (list) */
620   /*   { */
621   /*     string = gcry_sexp_nth_string (list, 1); */
622   /*     if (!string) */
623   /*       goto bad_seckey; */
624   /*     desired_csum = strtoul (string, NULL, 10); */
625   /*     xfree (string); */
626   /*   } */
627   /* else */
628   /*   desired_csum = 0; */
629   /* gcry_sexp_release (list); list = NULL; */
630
631   /* Get the curve name if any,  */
632   list = gcry_sexp_find_token (top_list, "curve", 0);
633   if (list)
634     {
635       curve = gcry_sexp_nth_string (list, 1);
636       gcry_sexp_release (list); list = NULL;
637     }
638
639   gcry_sexp_release (top_list); top_list = NULL;
640
641   /* log_debug ("XXX is_v4=%d\n", is_v4); */
642   /* log_debug ("XXX pubkey_algo=%d\n", pubkey_algo); */
643   /* log_debug ("XXX is_protected=%d\n", is_protected); */
644   /* log_debug ("XXX protect_algo=%d\n", protect_algo); */
645   /* log_printhex ("XXX iv", iv, ivlen); */
646   /* log_debug ("XXX ivlen=%d\n", ivlen); */
647   /* log_debug ("XXX s2k_mode=%d\n", s2k_mode); */
648   /* log_debug ("XXX s2k_algo=%d\n", s2k_algo); */
649   /* log_printhex ("XXX s2k_salt", s2k_salt, sizeof s2k_salt); */
650   /* log_debug ("XXX s2k_count=%lu\n", (unsigned long)s2k_count); */
651   /* for (idx=0; skey[idx]; idx++) */
652   /*   { */
653   /*     int is_enc = gcry_mpi_get_flag (skey[idx], GCRYMPI_FLAG_OPAQUE); */
654   /*     log_info ("XXX skey[%d]%s:", idx, is_enc? " (enc)":""); */
655   /*     if (is_enc) */
656   /*       { */
657   /*         void *p; */
658   /*         unsigned int nbits; */
659   /*         p = gcry_mpi_get_opaque (skey[idx], &nbits); */
660   /*         log_printhex (NULL, p, (nbits+7)/8); */
661   /*       } */
662   /*     else */
663   /*       gcry_mpi_dump (skey[idx]); */
664   /*     log_printf ("\n"); */
665   /*   } */
666
667   if (!is_v4 || is_protected != 2 )
668     {
669       /* We only support the v4 format and a SHA-1 checksum.  */
670       err = gpg_error (GPG_ERR_NOT_IMPLEMENTED);
671       goto leave;
672     }
673
674   /* We need to change the received parameters for ECC algorithms.
675      The transfer format has the curve name and the parameters
676      separate.  We put them all into the SKEY array.  */
677   if (canon_pk_algo (pk_algo) == GCRY_PK_ECC)
678     {
679       const char *oidstr;
680
681       /* Assert that all required parameters are available.  We also
682          check that the array does not contain more parameters than
683          needed (this was used by some beta versions of 2.1.  */
684       if (!curve || !skey[0] || !skey[1] || skey[2])
685         {
686           err = gpg_error (GPG_ERR_INTERNAL);
687           goto leave;
688         }
689
690       oidstr = openpgp_curve_to_oid (curve, NULL);
691       if (!oidstr)
692         {
693           log_error ("no OID known for curve '%s'\n", curve);
694           err = gpg_error (GPG_ERR_UNKNOWN_CURVE);
695           goto leave;
696         }
697       /* Put the curve's OID into into the MPI array.  This requires
698          that we shift Q and D.  For ECDH also insert the KDF parms. */
699       if (is_ecdh)
700         {
701           skey[4] = NULL;
702           skey[3] = skey[1];
703           skey[2] = gcry_mpi_copy (pk->pkey[2]);
704         }
705       else
706         {
707           skey[3] = NULL;
708           skey[2] = skey[1];
709         }
710       skey[1] = skey[0];
711       skey[0] = NULL;
712       err = openpgp_oid_from_str (oidstr, skey + 0);
713       if (err)
714         goto leave;
715       /* Fixup the NPKEY and NSKEY to match OpenPGP reality.  */
716       npkey = 2 + is_ecdh;
717       nskey = 3 + is_ecdh;
718
719       /* for (idx=0; skey[idx]; idx++) */
720       /*   { */
721       /*     log_info ("YYY skey[%d]:", idx); */
722       /*     if (gcry_mpi_get_flag (skey[idx], GCRYMPI_FLAG_OPAQUE)) */
723       /*       { */
724       /*         void *p; */
725       /*         unsigned int nbits; */
726       /*         p = gcry_mpi_get_opaque (skey[idx], &nbits); */
727       /*         log_printhex (NULL, p, (nbits+7)/8); */
728       /*       } */
729       /*     else */
730       /*       gcry_mpi_dump (skey[idx]); */
731       /*     log_printf ("\n"); */
732       /*   } */
733     }
734
735   /* Do some sanity checks.  */
736   if (s2k_count > 255)
737     {
738       /* We expect an already encoded S2K count.  */
739       err = gpg_error (GPG_ERR_INV_DATA);
740       goto leave;
741     }
742   err = openpgp_cipher_test_algo (protect_algo);
743   if (err)
744     goto leave;
745   err = openpgp_md_test_algo (s2k_algo);
746   if (err)
747     goto leave;
748
749   /* Check that the public key parameters match.  Note that since
750      Libgcrypt 1.5 gcry_mpi_cmp handles opaque MPI correctly.  */
751   for (idx=0; idx < npkey; idx++)
752     if (gcry_mpi_cmp (pk->pkey[idx], skey[idx]))
753       {
754         err = gpg_error (GPG_ERR_BAD_PUBKEY);
755         goto leave;
756       }
757
758   /* Check that the first secret key parameter in SKEY is encrypted
759      and that there are no more secret key parameters.  The latter is
760      guaranteed by the v4 packet format.  */
761   if (!gcry_mpi_get_flag (skey[npkey], GCRYMPI_FLAG_OPAQUE))
762     goto bad_seckey;
763   if (npkey+1 < DIM (skey) && skey[npkey+1])
764     goto bad_seckey;
765
766   /* Check that the secret key parameters in PK are all set to NULL. */
767   for (idx=npkey; idx < nskey; idx++)
768     if (pk->pkey[idx])
769       goto bad_seckey;
770
771   /* Now build the protection info. */
772   pk->seckey_info = ski = xtrycalloc (1, sizeof *ski);
773   if (!ski)
774     {
775       err = gpg_error_from_syserror ();
776       goto leave;
777     }
778
779   ski->is_protected = 1;
780   ski->sha1chk = 1;
781   ski->algo = protect_algo;
782   ski->s2k.mode = s2k_mode;
783   ski->s2k.hash_algo = s2k_algo;
784   assert (sizeof ski->s2k.salt == sizeof s2k_salt);
785   memcpy (ski->s2k.salt, s2k_salt, sizeof s2k_salt);
786   ski->s2k.count = s2k_count;
787   assert (ivlen <= sizeof ski->iv);
788   memcpy (ski->iv, iv, ivlen);
789   ski->ivlen = ivlen;
790
791   /* Store the protected secret key parameter.  */
792   pk->pkey[npkey] = skey[npkey];
793   skey[npkey] = NULL;
794
795   /* That's it.  */
796
797  leave:
798   gcry_free (curve);
799   gcry_sexp_release (list);
800   gcry_sexp_release (top_list);
801   for (idx=0; idx < skeyidx; idx++)
802     gcry_mpi_release (skey[idx]);
803   return err;
804
805  bad_seckey:
806   err = gpg_error (GPG_ERR_BAD_SECKEY);
807   goto leave;
808
809  outofmem:
810   err = gpg_error (GPG_ERR_ENOMEM);
811   goto leave;
812 }
813
814
815 /* Print an "EXPORTED" status line.  PK is the primary public key.  */
816 static void
817 print_status_exported (PKT_public_key *pk)
818 {
819   char *hexfpr;
820
821   if (!is_status_enabled ())
822     return;
823
824   hexfpr = hexfingerprint (pk, NULL, 0);
825   write_status_text (STATUS_EXPORTED, hexfpr? hexfpr : "[?]");
826   xfree (hexfpr);
827 }
828
829
830 /*
831  * Receive a secret key from agent specified by HEXGRIP.
832  *
833  * Since the key data from agant is encrypted, decrypt it by CIPHERHD.
834  * Then, parse the decrypted key data in transfer format, and put
835  * secret papameters into PK.
836  *
837  * CACHE_NONCE_ADDR is used to share nonce for multple key retrievals.
838  */
839 gpg_error_t
840 receive_seckey_from_agent (ctrl_t ctrl, gcry_cipher_hd_t cipherhd,
841                            char **cache_nonce_addr, const char *hexgrip,
842                            PKT_public_key *pk)
843 {
844   gpg_error_t err = 0;
845   unsigned char *wrappedkey = NULL;
846   size_t wrappedkeylen;
847   unsigned char *key = NULL;
848   size_t keylen, realkeylen;
849   gcry_sexp_t s_skey;
850   char *prompt;
851
852   if (opt.verbose)
853     log_info ("key %s: asking agent for the secret parts\n", hexgrip);
854
855   prompt = gpg_format_keydesc (pk, FORMAT_KEYDESC_EXPORT,1);
856   err = agent_export_key (ctrl, hexgrip, prompt, cache_nonce_addr,
857                           &wrappedkey, &wrappedkeylen);
858   xfree (prompt);
859
860   if (err)
861     goto unwraperror;
862   if (wrappedkeylen < 24)
863     {
864       err = gpg_error (GPG_ERR_INV_LENGTH);
865       goto unwraperror;
866     }
867   keylen = wrappedkeylen - 8;
868   key = xtrymalloc_secure (keylen);
869   if (!key)
870     {
871       err = gpg_error_from_syserror ();
872       goto unwraperror;
873     }
874   err = gcry_cipher_decrypt (cipherhd, key, keylen, wrappedkey, wrappedkeylen);
875   if (err)
876     goto unwraperror;
877   realkeylen = gcry_sexp_canon_len (key, keylen, NULL, &err);
878   if (!realkeylen)
879     goto unwraperror; /* Invalid csexp.  */
880
881   err = gcry_sexp_sscan (&s_skey, NULL, key, realkeylen);
882   if (!err)
883     {
884       err = transfer_format_to_openpgp (s_skey, pk);
885       gcry_sexp_release (s_skey);
886     }
887
888  unwraperror:
889   xfree (key);
890   xfree (wrappedkey);
891   if (err)
892     {
893       log_error ("key %s: error receiving key from agent:"
894                  " %s%s\n", hexgrip, gpg_strerror (err),
895                  gpg_err_code (err) == GPG_ERR_FULLY_CANCELED?
896                  "":_(" - skipped"));
897     }
898   return err;
899 }
900
901
902 /* Export the keys identified by the list of strings in USERS to the
903    stream OUT.  If Secret is false public keys will be exported.  With
904    secret true secret keys will be exported; in this case 1 means the
905    entire secret keyblock and 2 only the subkeys.  OPTIONS are the
906    export options to apply.  If KEYBLOCK_OUT is not NULL, AND the exit
907    code is zero, a pointer to the first keyblock found and exported
908    will be stored at this address; no other keyblocks are exported in
909    this case.  The caller must free the returned keyblock.  If any
910    key has been exported true is stored at ANY. */
911 static int
912 do_export_stream (ctrl_t ctrl, iobuf_t out, strlist_t users, int secret,
913                   kbnode_t *keyblock_out, unsigned int options,
914                   export_stats_t stats, int *any)
915 {
916   gpg_error_t err = 0;
917   PACKET pkt;
918   KBNODE keyblock = NULL;
919   KBNODE kbctx, node;
920   size_t ndesc, descindex;
921   KEYDB_SEARCH_DESC *desc = NULL;
922   subkey_list_t subkey_list = NULL;  /* Track already processed subkeys. */
923   KEYDB_HANDLE kdbhd;
924   strlist_t sl;
925   gcry_cipher_hd_t cipherhd = NULL;
926   char *cache_nonce = NULL;
927   struct export_stats_s dummystats;
928
929   if (!stats)
930     stats = &dummystats;
931   *any = 0;
932   init_packet (&pkt);
933   kdbhd = keydb_new ();
934   if (!kdbhd)
935     return gpg_error_from_syserror ();
936
937   /* For the DANE format override the options.  */
938   if ((options & EXPORT_DANE_FORMAT))
939     options = (EXPORT_DANE_FORMAT | EXPORT_MINIMAL | EXPORT_CLEAN);
940
941
942   if (!users)
943     {
944       ndesc = 1;
945       desc = xcalloc (ndesc, sizeof *desc);
946       desc[0].mode = KEYDB_SEARCH_MODE_FIRST;
947     }
948   else
949     {
950       for (ndesc=0, sl=users; sl; sl = sl->next, ndesc++)
951         ;
952       desc = xmalloc ( ndesc * sizeof *desc);
953
954       for (ndesc=0, sl=users; sl; sl = sl->next)
955         {
956           if (!(err=classify_user_id (sl->d, desc+ndesc, 1)))
957             ndesc++;
958           else
959             log_error (_("key \"%s\" not found: %s\n"),
960                        sl->d, gpg_strerror (err));
961         }
962
963       keydb_disable_caching (kdbhd);  /* We are looping the search.  */
964
965       /* It would be nice to see which of the given users did actually
966          match one in the keyring.  To implement this we need to have
967          a found flag for each entry in desc.  To set this flag we
968          must check all those entries after a match to mark all
969          matched one - currently we stop at the first match.  To do
970          this we need an extra flag to enable this feature.  */
971     }
972
973 #ifdef ENABLE_SELINUX_HACKS
974   if (secret)
975     {
976       log_error (_("exporting secret keys not allowed\n"));
977       err = gpg_error (GPG_ERR_NOT_SUPPORTED);
978       goto leave;
979     }
980 #endif
981
982   /* For secret key export we need to setup a decryption context.  */
983   if (secret)
984     {
985       void *kek = NULL;
986       size_t keklen;
987
988       err = agent_keywrap_key (ctrl, 1, &kek, &keklen);
989       if (err)
990         {
991           log_error ("error getting the KEK: %s\n", gpg_strerror (err));
992           goto leave;
993         }
994
995       /* Prepare a cipher context.  */
996       err = gcry_cipher_open (&cipherhd, GCRY_CIPHER_AES128,
997                               GCRY_CIPHER_MODE_AESWRAP, 0);
998       if (!err)
999         err = gcry_cipher_setkey (cipherhd, kek, keklen);
1000       if (err)
1001         {
1002           log_error ("error setting up an encryption context: %s\n",
1003                      gpg_strerror (err));
1004           goto leave;
1005         }
1006       xfree (kek);
1007       kek = NULL;
1008     }
1009
1010   for (;;)
1011     {
1012       int skip_until_subkey = 0;
1013       u32 keyid[2];
1014       PKT_public_key *pk;
1015
1016       err = keydb_search (kdbhd, desc, ndesc, &descindex);
1017       if (!users)
1018         desc[0].mode = KEYDB_SEARCH_MODE_NEXT;
1019       if (err)
1020         break;
1021
1022       /* Read the keyblock. */
1023       release_kbnode (keyblock);
1024       keyblock = NULL;
1025       err = keydb_get_keyblock (kdbhd, &keyblock);
1026       if (err)
1027         {
1028           log_error (_("error reading keyblock: %s\n"), gpg_strerror (err));
1029           goto leave;
1030         }
1031
1032       node = find_kbnode (keyblock, PKT_PUBLIC_KEY);
1033       if (!node)
1034         {
1035           log_error ("public key packet not found in keyblock - skipped\n");
1036           continue;
1037         }
1038       stats->count++;
1039       setup_main_keyids (keyblock);  /* gpg_format_keydesc needs it.  */
1040       pk = node->pkt->pkt.public_key;
1041       keyid_from_pk (pk, keyid);
1042
1043       /* If a secret key export is required we need to check whether
1044          we have a secret key at all and if so create the seckey_info
1045          structure.  */
1046       if (secret)
1047         {
1048           if (agent_probe_any_secret_key (ctrl, keyblock))
1049             continue;  /* No secret key (neither primary nor subkey).  */
1050
1051           /* No v3 keys with GNU mode 1001. */
1052           if (secret == 2 && pk->version == 3)
1053             {
1054               log_info (_("key %s: PGP 2.x style key - skipped\n"),
1055                         keystr (keyid));
1056               continue;
1057             }
1058
1059           /* The agent does not yet allow to export v3 packets.  It is
1060              actually questionable whether we should allow them at
1061              all.  */
1062           if (pk->version == 3)
1063             {
1064               log_info ("key %s: PGP 2.x style key (v3) export "
1065                         "not yet supported - skipped\n", keystr (keyid));
1066               continue;
1067             }
1068           stats->secret_count++;
1069         }
1070
1071       /* Always do the cleaning on the public key part if requested.
1072          Note that we don't yet set this option if we are exporting
1073          secret keys.  Note that both export-clean and export-minimal
1074          only apply to UID sigs (0x10, 0x11, 0x12, and 0x13).  A
1075          designated revocation is never stripped, even with
1076          export-minimal set.  */
1077       if ((options & EXPORT_CLEAN))
1078         clean_key (keyblock, opt.verbose, (options&EXPORT_MINIMAL), NULL, NULL);
1079
1080       /* And write it. */
1081       xfree (cache_nonce);
1082       cache_nonce = NULL;
1083       for (kbctx=NULL; (node = walk_kbnode (keyblock, &kbctx, 0)); )
1084         {
1085           if (skip_until_subkey)
1086             {
1087               if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
1088                 skip_until_subkey = 0;
1089               else
1090                 continue;
1091             }
1092
1093           /* We used to use comment packets, but not any longer.  In
1094              case we still have comments on a key, strip them here
1095              before we call build_packet(). */
1096           if (node->pkt->pkttype == PKT_COMMENT)
1097             continue;
1098
1099           /* Make sure that ring_trust packets never get exported. */
1100           if (node->pkt->pkttype == PKT_RING_TRUST)
1101             continue;
1102
1103           /* If exact is set, then we only export what was requested
1104              (plus the primary key, if the user didn't specifically
1105              request it). */
1106           if (desc[descindex].exact
1107               && node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
1108             {
1109               if (!exact_subkey_match_p (desc+descindex, node))
1110                 {
1111                   /* Before skipping this subkey, check whether any
1112                      other description wants an exact match on a
1113                      subkey and include that subkey into the output
1114                      too.  Need to add this subkey to a list so that
1115                      it won't get processed a second time.
1116
1117                      So the first step here is to check that list and
1118                      skip in any case if the key is in that list.
1119
1120                      We need this whole mess because the import
1121                      function of GnuPG < 2.1 is not able to merge
1122                      secret keys and thus it is useless to output them
1123                      as two separate keys and have import merge them.  */
1124                   if (subkey_in_list_p (subkey_list, node))
1125                     skip_until_subkey = 1; /* Already processed this one. */
1126                   else
1127                     {
1128                       size_t j;
1129
1130                       for (j=0; j < ndesc; j++)
1131                         if (j != descindex && desc[j].exact
1132                             && exact_subkey_match_p (desc+j, node))
1133                           break;
1134                       if (!(j < ndesc))
1135                         skip_until_subkey = 1; /* No other one matching. */
1136                     }
1137                 }
1138
1139               if(skip_until_subkey)
1140                 continue;
1141
1142               /* Mark this one as processed. */
1143               {
1144                 subkey_list_t tmp = new_subkey_list_item (node);
1145                 tmp->next = subkey_list;
1146                 subkey_list = tmp;
1147               }
1148             }
1149
1150           if (node->pkt->pkttype == PKT_SIGNATURE)
1151             {
1152               /* Do not export packets which are marked as not
1153                  exportable.  */
1154               if (!(options&EXPORT_LOCAL_SIGS)
1155                   && !node->pkt->pkt.signature->flags.exportable)
1156                 continue; /* not exportable */
1157
1158               /* Do not export packets with a "sensitive" revocation
1159                  key unless the user wants us to.  Note that we do
1160                  export these when issuing the actual revocation
1161                  (see revoke.c). */
1162               if (!(options&EXPORT_SENSITIVE_REVKEYS)
1163                   && node->pkt->pkt.signature->revkey)
1164                 {
1165                   int i;
1166
1167                   for (i=0;i<node->pkt->pkt.signature->numrevkeys;i++)
1168                     if ( (node->pkt->pkt.signature->revkey[i].class & 0x40))
1169                       break;
1170
1171                   if (i < node->pkt->pkt.signature->numrevkeys)
1172                     continue;
1173                 }
1174             }
1175
1176           /* Don't export attribs? */
1177           if (!(options&EXPORT_ATTRIBUTES)
1178               && node->pkt->pkttype == PKT_USER_ID
1179               && node->pkt->pkt.user_id->attrib_data )
1180             {
1181               /* Skip until we get to something that is not an attrib
1182                  or a signature on an attrib */
1183               while (kbctx->next && kbctx->next->pkt->pkttype==PKT_SIGNATURE)
1184                 kbctx = kbctx->next;
1185
1186               continue;
1187             }
1188
1189           if (secret && (node->pkt->pkttype == PKT_PUBLIC_KEY
1190                          || node->pkt->pkttype == PKT_PUBLIC_SUBKEY))
1191             {
1192               u32 subkidbuf[2], *subkid;
1193               char *hexgrip, *serialno;
1194
1195               pk = node->pkt->pkt.public_key;
1196               if (node->pkt->pkttype == PKT_PUBLIC_KEY)
1197                 subkid = NULL;
1198               else
1199                 {
1200                   keyid_from_pk (pk, subkidbuf);
1201                   subkid = subkidbuf;
1202                 }
1203
1204               if (pk->seckey_info)
1205                 {
1206                   log_error ("key %s: oops: seckey_info already set"
1207                              " - skipped\n", keystr_with_sub (keyid, subkid));
1208                   skip_until_subkey = 1;
1209                   continue;
1210                 }
1211
1212               err = hexkeygrip_from_pk (pk, &hexgrip);
1213               if (err)
1214                 {
1215                   log_error ("key %s: error computing keygrip: %s"
1216                              " - skipped\n", keystr_with_sub (keyid, subkid),
1217                              gpg_strerror (err));
1218                   skip_until_subkey = 1;
1219                   err = 0;
1220                   continue;
1221                 }
1222
1223               if (secret == 2 && node->pkt->pkttype == PKT_PUBLIC_KEY)
1224                 {
1225                   /* We are asked not to export the secret parts of
1226                      the primary key.  Make up an error code to create
1227                      the stub.  */
1228                   err = GPG_ERR_NOT_FOUND;
1229                   serialno = NULL;
1230                 }
1231               else
1232                 err = agent_get_keyinfo (ctrl, hexgrip, &serialno);
1233
1234               if ((!err && serialno)
1235                   && secret == 2 && node->pkt->pkttype == PKT_PUBLIC_KEY)
1236                 {
1237                   /* It does not make sense to export a key with its
1238                      primary key on card using a non-key stub.  Thus
1239                      we skip those keys when used with
1240                      --export-secret-subkeys. */
1241                   log_info (_("key %s: key material on-card - skipped\n"),
1242                             keystr_with_sub (keyid, subkid));
1243                   skip_until_subkey = 1;
1244                 }
1245               else if (gpg_err_code (err) == GPG_ERR_NOT_FOUND
1246                        || (!err && serialno))
1247                 {
1248                   /* Create a key stub.  */
1249                   struct seckey_info *ski;
1250                   const char *s;
1251
1252                   pk->seckey_info = ski = xtrycalloc (1, sizeof *ski);
1253                   if (!ski)
1254                     {
1255                       err = gpg_error_from_syserror ();
1256                       xfree (hexgrip);
1257                       goto leave;
1258                     }
1259
1260                   ski->is_protected = 1;
1261                   if (err)
1262                     ski->s2k.mode = 1001; /* GNU dummy (no secret key).  */
1263                   else
1264                     {
1265                       ski->s2k.mode = 1002; /* GNU-divert-to-card.  */
1266                       for (s=serialno; sizeof (ski->ivlen) && *s && s[1];
1267                            ski->ivlen++, s += 2)
1268                         ski->iv[ski->ivlen] = xtoi_2 (s);
1269                     }
1270
1271                   err = build_packet (out, node->pkt);
1272                   if (!err && node->pkt->pkttype == PKT_PUBLIC_KEY)
1273                     {
1274                       stats->exported++;
1275                       print_status_exported (node->pkt->pkt.public_key);
1276                     }
1277                 }
1278               else if (!err)
1279                 {
1280                   err = receive_seckey_from_agent (ctrl, cipherhd, &cache_nonce,
1281                                                    hexgrip, pk);
1282                   if (err)
1283                     {
1284                       if (gpg_err_code (err) == GPG_ERR_FULLY_CANCELED)
1285                         goto leave;
1286                       skip_until_subkey = 1;
1287                       err = 0;
1288                     }
1289                   else
1290                     {
1291                       err = build_packet (out, node->pkt);
1292                       if (node->pkt->pkttype == PKT_PUBLIC_KEY)
1293                         {
1294                           stats->exported++;
1295                           print_status_exported (node->pkt->pkt.public_key);
1296                         }
1297                     }
1298                 }
1299               else
1300                 {
1301                   log_error ("key %s: error getting keyinfo from agent: %s"
1302                              " - skipped\n", keystr_with_sub (keyid, subkid),
1303                              gpg_strerror (err));
1304                   skip_until_subkey = 1;
1305                   err = 0;
1306                 }
1307
1308               xfree (pk->seckey_info);
1309               pk->seckey_info = NULL;
1310               xfree (hexgrip);
1311             }
1312           else
1313             {
1314               err = build_packet (out, node->pkt);
1315               if (!err && node->pkt->pkttype == PKT_PUBLIC_KEY)
1316                 {
1317                   stats->exported++;
1318                   print_status_exported (node->pkt->pkt.public_key);
1319                 }
1320             }
1321
1322
1323           if (err)
1324             {
1325               log_error ("build_packet(%d) failed: %s\n",
1326                          node->pkt->pkttype, gpg_strerror (err));
1327               goto leave;
1328             }
1329
1330           if (!skip_until_subkey)
1331             *any = 1;
1332         }
1333
1334       if (keyblock_out)
1335         {
1336           *keyblock_out = keyblock;
1337           break;
1338         }
1339     }
1340   if (gpg_err_code (err) == GPG_ERR_NOT_FOUND)
1341     err = 0;
1342
1343  leave:
1344   gcry_cipher_close (cipherhd);
1345   release_subkey_list (subkey_list);
1346   xfree(desc);
1347   keydb_release (kdbhd);
1348   if (err || !keyblock_out)
1349     release_kbnode( keyblock );
1350   xfree (cache_nonce);
1351   if( !*any )
1352     log_info(_("WARNING: nothing exported\n"));
1353   return err;
1354 }
1355
1356
1357
1358 \f
1359 static gpg_error_t
1360 key_to_sshblob (membuf_t *mb, const char *identifier, ...)
1361 {
1362   va_list arg_ptr;
1363   gpg_error_t err = 0;
1364   unsigned char nbuf[4];
1365   unsigned char *buf;
1366   size_t buflen;
1367   gcry_mpi_t a;
1368
1369   ulongtobuf (nbuf, (ulong)strlen (identifier));
1370   put_membuf (mb, nbuf, 4);
1371   put_membuf_str (mb, identifier);
1372   if (!strncmp (identifier, "ecdsa-sha2-", 11))
1373     {
1374       ulongtobuf (nbuf, (ulong)strlen (identifier+11));
1375       put_membuf (mb, nbuf, 4);
1376       put_membuf_str (mb, identifier+11);
1377     }
1378   va_start (arg_ptr, identifier);
1379   while ((a = va_arg (arg_ptr, gcry_mpi_t)))
1380     {
1381       err = gcry_mpi_aprint (GCRYMPI_FMT_SSH, &buf, &buflen, a);
1382       if (err)
1383         break;
1384       if (!strcmp (identifier, "ssh-ed25519")
1385           && buflen > 5 && buf[4] == 0x40)
1386         {
1387           /* We need to strip our 0x40 prefix.  */
1388           put_membuf (mb, "\x00\x00\x00\x20", 4);
1389           put_membuf (mb, buf+5, buflen-5);
1390         }
1391       else
1392         put_membuf (mb, buf, buflen);
1393       gcry_free (buf);
1394     }
1395   va_end (arg_ptr);
1396   return err;
1397 }
1398
1399 /* Export the key identified by USERID in the SSH public key format.
1400    The function exports the latest subkey with Authentication
1401    capability unless the '!' suffix is used to export a specific
1402    key.  */
1403 gpg_error_t
1404 export_ssh_key (ctrl_t ctrl, const char *userid)
1405 {
1406   gpg_error_t err;
1407   kbnode_t keyblock = NULL;
1408   KEYDB_SEARCH_DESC desc;
1409   u32 latest_date;
1410   u32 curtime = make_timestamp ();
1411   kbnode_t latest_key, node;
1412   PKT_public_key *pk;
1413   const char *identifier;
1414   membuf_t mb;
1415   estream_t fp = NULL;
1416   struct b64state b64_state;
1417   const char *fname = "-";
1418
1419   init_membuf (&mb, 4096);
1420
1421   /* We need to know whether the key has been specified using the
1422      exact syntax ('!' suffix).  Thus we need to run a
1423      classify_user_id on our own.  */
1424   err = classify_user_id (userid, &desc, 1);
1425
1426   /* Get the public key.  */
1427   if (!err)
1428     {
1429       getkey_ctx_t getkeyctx;
1430
1431       err = get_pubkey_byname (ctrl, &getkeyctx, NULL, userid, &keyblock,
1432                                NULL,
1433                                0  /* Only usable keys or given exact. */,
1434                                1  /* No AKL lookup.  */);
1435       if (!err)
1436         {
1437           err = getkey_next (getkeyctx, NULL, NULL);
1438           if (!err)
1439             err = gpg_error (GPG_ERR_AMBIGUOUS_NAME);
1440           else if (gpg_err_code (err) == GPG_ERR_NO_PUBKEY)
1441             err = 0;
1442         }
1443       getkey_end (getkeyctx);
1444     }
1445   if (err)
1446     {
1447       log_error (_("key \"%s\" not found: %s\n"), userid, gpg_strerror (err));
1448       return err;
1449     }
1450
1451   /* The finish_lookup code in getkey.c does not handle auth keys,
1452      thus we have to duplicate the code here to find the latest
1453      subkey.  However, if the key has been found using an exact match
1454      ('!' notation) we use that key without any further checks and
1455      even allow the use of the primary key. */
1456   latest_date = 0;
1457   latest_key = NULL;
1458   for (node = keyblock; node; node = node->next)
1459     {
1460       if ((node->pkt->pkttype == PKT_PUBLIC_SUBKEY
1461            || node->pkt->pkttype == PKT_PUBLIC_KEY)
1462           && node->pkt->pkt.public_key->flags.exact)
1463         {
1464           latest_key = node;
1465           break;
1466         }
1467     }
1468   if (!latest_key)
1469     {
1470       for (node = keyblock; node; node = node->next)
1471         {
1472           if (node->pkt->pkttype != PKT_PUBLIC_SUBKEY)
1473             continue;
1474
1475           pk = node->pkt->pkt.public_key;
1476           if (DBG_LOOKUP)
1477             log_debug ("\tchecking subkey %08lX\n",
1478                        (ulong) keyid_from_pk (pk, NULL));
1479           if (!(pk->pubkey_usage & PUBKEY_USAGE_AUTH))
1480             {
1481               if (DBG_LOOKUP)
1482                 log_debug ("\tsubkey not usable for authentication\n");
1483               continue;
1484             }
1485           if (!pk->flags.valid)
1486             {
1487               if (DBG_LOOKUP)
1488                 log_debug ("\tsubkey not valid\n");
1489               continue;
1490             }
1491           if (pk->flags.revoked)
1492             {
1493               if (DBG_LOOKUP)
1494                 log_debug ("\tsubkey has been revoked\n");
1495               continue;
1496             }
1497           if (pk->has_expired)
1498             {
1499               if (DBG_LOOKUP)
1500                 log_debug ("\tsubkey has expired\n");
1501               continue;
1502             }
1503           if (pk->timestamp > curtime && !opt.ignore_valid_from)
1504             {
1505               if (DBG_LOOKUP)
1506                 log_debug ("\tsubkey not yet valid\n");
1507               continue;
1508             }
1509           if (DBG_LOOKUP)
1510             log_debug ("\tsubkey might be fine\n");
1511           /* In case a key has a timestamp of 0 set, we make sure that it
1512              is used.  A better change would be to compare ">=" but that
1513              might also change the selected keys and is as such a more
1514              intrusive change.  */
1515           if (pk->timestamp > latest_date || (!pk->timestamp && !latest_date))
1516             {
1517               latest_date = pk->timestamp;
1518               latest_key = node;
1519             }
1520         }
1521     }
1522
1523   if (!latest_key)
1524     {
1525       err = gpg_error (GPG_ERR_UNUSABLE_PUBKEY);
1526       log_error (_("key \"%s\" not found: %s\n"), userid, gpg_strerror (err));
1527       goto leave;
1528     }
1529
1530   pk = latest_key->pkt->pkt.public_key;
1531   if (DBG_LOOKUP)
1532     log_debug ("\tusing key %08lX\n", (ulong) keyid_from_pk (pk, NULL));
1533
1534   switch (pk->pubkey_algo)
1535     {
1536     case PUBKEY_ALGO_DSA:
1537       identifier = "ssh-dss";
1538       err = key_to_sshblob (&mb, identifier,
1539                             pk->pkey[0], pk->pkey[1], pk->pkey[2], pk->pkey[3],
1540                             NULL);
1541       break;
1542
1543     case PUBKEY_ALGO_RSA:
1544     case PUBKEY_ALGO_RSA_S:
1545       identifier = "ssh-rsa";
1546       err = key_to_sshblob (&mb, identifier, pk->pkey[1], pk->pkey[0], NULL);
1547       break;
1548
1549     case PUBKEY_ALGO_ECDSA:
1550       {
1551         char *curveoid;
1552         const char *curve;
1553
1554         curveoid = openpgp_oid_to_str (pk->pkey[0]);
1555         if (!curveoid)
1556           err = gpg_error_from_syserror ();
1557         else if (!(curve = openpgp_oid_to_curve (curveoid, 0)))
1558           err = gpg_error (GPG_ERR_UNKNOWN_CURVE);
1559         else
1560           {
1561             if (!strcmp (curve, "nistp256"))
1562               identifier = "ecdsa-sha2-nistp256";
1563             else if (!strcmp (curve, "nistp384"))
1564               identifier = "ecdsa-sha2-nistp384";
1565             else if (!strcmp (curve, "nistp521"))
1566               identifier = "ecdsa-sha2-nistp521";
1567             else
1568               identifier = NULL;
1569
1570             if (!identifier)
1571               err = gpg_error (GPG_ERR_UNKNOWN_CURVE);
1572             else
1573               err = key_to_sshblob (&mb, identifier, pk->pkey[1], NULL);
1574           }
1575         xfree (curveoid);
1576       }
1577       break;
1578
1579     case PUBKEY_ALGO_EDDSA:
1580       if (!openpgp_oid_is_ed25519 (pk->pkey[0]))
1581         err = gpg_error (GPG_ERR_UNKNOWN_CURVE);
1582       else
1583         {
1584           identifier = "ssh-ed25519";
1585           err = key_to_sshblob (&mb, identifier, pk->pkey[1], NULL);
1586         }
1587       break;
1588
1589     case PUBKEY_ALGO_ELGAMAL_E:
1590     case PUBKEY_ALGO_ELGAMAL:
1591       err = gpg_error (GPG_ERR_UNUSABLE_PUBKEY);
1592       break;
1593
1594     default:
1595       err = GPG_ERR_PUBKEY_ALGO;
1596       break;
1597     }
1598
1599   if (err)
1600     goto leave;
1601
1602   if (opt.outfile && *opt.outfile && strcmp (opt.outfile, "-"))
1603     fp = es_fopen ((fname = opt.outfile), "w");
1604   else
1605     fp = es_stdout;
1606   if (!fp)
1607     {
1608       err = gpg_error_from_syserror ();
1609       log_error (_("error creating '%s': %s\n"), fname, gpg_strerror (err));
1610       goto leave;
1611     }
1612
1613   es_fprintf (fp, "%s ", identifier);
1614   err = b64enc_start_es (&b64_state, fp, "");
1615   if (err)
1616     goto leave;
1617   {
1618     void *blob;
1619     size_t bloblen;
1620
1621     blob = get_membuf (&mb, &bloblen);
1622     if (!blob)
1623       err = gpg_error_from_syserror ();
1624     else
1625       err = b64enc_write (&b64_state, blob, bloblen);
1626     xfree (blob);
1627     if (err)
1628       goto leave;
1629   }
1630   err = b64enc_finish (&b64_state);
1631   if (err)
1632     goto leave;
1633   es_fprintf (fp, " openpgp:0x%08lX\n", (ulong)keyid_from_pk (pk, NULL));
1634
1635   if (es_ferror (fp))
1636     err = gpg_error_from_syserror ();
1637   else
1638     {
1639       if (es_fclose (fp))
1640         err = gpg_error_from_syserror ();
1641       fp = NULL;
1642     }
1643
1644   if (err)
1645     log_error (_("error writing '%s': %s\n"), fname, gpg_strerror (err));
1646
1647  leave:
1648   es_fclose (fp);
1649   xfree (get_membuf (&mb, NULL));
1650   release_kbnode (keyblock);
1651   return err;
1652 }