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