g10: Allow receiving cleartext secret keys from agent
[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
1145   if (!stats)
1146     stats = &dummystats;
1147   *any = 0;
1148   init_packet (&pkt);
1149   kdbhd = keydb_new ();
1150   if (!kdbhd)
1151     return gpg_error_from_syserror ();
1152
1153   /* For the DANE format override the options.  */
1154   if ((options & EXPORT_DANE_FORMAT))
1155     options = (EXPORT_DANE_FORMAT | EXPORT_MINIMAL | EXPORT_CLEAN);
1156
1157
1158   if (!users)
1159     {
1160       ndesc = 1;
1161       desc = xcalloc (ndesc, sizeof *desc);
1162       desc[0].mode = KEYDB_SEARCH_MODE_FIRST;
1163     }
1164   else
1165     {
1166       for (ndesc=0, sl=users; sl; sl = sl->next, ndesc++)
1167         ;
1168       desc = xmalloc ( ndesc * sizeof *desc);
1169
1170       for (ndesc=0, sl=users; sl; sl = sl->next)
1171         {
1172           if (!(err=classify_user_id (sl->d, desc+ndesc, 1)))
1173             ndesc++;
1174           else
1175             log_error (_("key \"%s\" not found: %s\n"),
1176                        sl->d, gpg_strerror (err));
1177         }
1178
1179       keydb_disable_caching (kdbhd);  /* We are looping the search.  */
1180
1181       /* It would be nice to see which of the given users did actually
1182          match one in the keyring.  To implement this we need to have
1183          a found flag for each entry in desc.  To set this flag we
1184          must check all those entries after a match to mark all
1185          matched one - currently we stop at the first match.  To do
1186          this we need an extra flag to enable this feature.  */
1187     }
1188
1189 #ifdef ENABLE_SELINUX_HACKS
1190   if (secret)
1191     {
1192       log_error (_("exporting secret keys not allowed\n"));
1193       err = gpg_error (GPG_ERR_NOT_SUPPORTED);
1194       goto leave;
1195     }
1196 #endif
1197
1198   /* For secret key export we need to setup a decryption context.  */
1199   if (secret)
1200     {
1201       void *kek = NULL;
1202       size_t keklen;
1203
1204       err = agent_keywrap_key (ctrl, 1, &kek, &keklen);
1205       if (err)
1206         {
1207           log_error ("error getting the KEK: %s\n", gpg_strerror (err));
1208           goto leave;
1209         }
1210
1211       /* Prepare a cipher context.  */
1212       err = gcry_cipher_open (&cipherhd, GCRY_CIPHER_AES128,
1213                               GCRY_CIPHER_MODE_AESWRAP, 0);
1214       if (!err)
1215         err = gcry_cipher_setkey (cipherhd, kek, keklen);
1216       if (err)
1217         {
1218           log_error ("error setting up an encryption context: %s\n",
1219                      gpg_strerror (err));
1220           goto leave;
1221         }
1222       xfree (kek);
1223       kek = NULL;
1224     }
1225
1226   for (;;)
1227     {
1228       int skip_until_subkey = 0;
1229       u32 keyid[2];
1230       PKT_public_key *pk;
1231
1232       err = keydb_search (kdbhd, desc, ndesc, &descindex);
1233       if (!users)
1234         desc[0].mode = KEYDB_SEARCH_MODE_NEXT;
1235       if (err)
1236         break;
1237
1238       /* Read the keyblock. */
1239       release_kbnode (keyblock);
1240       keyblock = NULL;
1241       err = keydb_get_keyblock (kdbhd, &keyblock);
1242       if (err)
1243         {
1244           log_error (_("error reading keyblock: %s\n"), gpg_strerror (err));
1245           goto leave;
1246         }
1247
1248       node = find_kbnode (keyblock, PKT_PUBLIC_KEY);
1249       if (!node)
1250         {
1251           log_error ("public key packet not found in keyblock - skipped\n");
1252           continue;
1253         }
1254       stats->count++;
1255       setup_main_keyids (keyblock);  /* gpg_format_keydesc needs it.  */
1256       pk = node->pkt->pkt.public_key;
1257       keyid_from_pk (pk, keyid);
1258
1259       /* If a secret key export is required we need to check whether
1260          we have a secret key at all and if so create the seckey_info
1261          structure.  */
1262       if (secret)
1263         {
1264           if (agent_probe_any_secret_key (ctrl, keyblock))
1265             continue;  /* No secret key (neither primary nor subkey).  */
1266
1267           /* No v3 keys with GNU mode 1001. */
1268           if (secret == 2 && pk->version == 3)
1269             {
1270               log_info (_("key %s: PGP 2.x style key - skipped\n"),
1271                         keystr (keyid));
1272               continue;
1273             }
1274
1275           /* The agent does not yet allow to export v3 packets.  It is
1276              actually questionable whether we should allow them at
1277              all.  */
1278           if (pk->version == 3)
1279             {
1280               log_info ("key %s: PGP 2.x style key (v3) export "
1281                         "not yet supported - skipped\n", keystr (keyid));
1282               continue;
1283             }
1284           stats->secret_count++;
1285         }
1286
1287       /* Always do the cleaning on the public key part if requested.
1288          Note that we don't yet set this option if we are exporting
1289          secret keys.  Note that both export-clean and export-minimal
1290          only apply to UID sigs (0x10, 0x11, 0x12, and 0x13).  A
1291          designated revocation is never stripped, even with
1292          export-minimal set.  */
1293       if ((options & EXPORT_CLEAN))
1294         clean_key (keyblock, opt.verbose, (options&EXPORT_MINIMAL), NULL, NULL);
1295
1296       /* And write it. */
1297       xfree (cache_nonce);
1298       cache_nonce = NULL;
1299       for (kbctx=NULL; (node = walk_kbnode (keyblock, &kbctx, 0)); )
1300         {
1301           if (skip_until_subkey)
1302             {
1303               if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
1304                 skip_until_subkey = 0;
1305               else
1306                 continue;
1307             }
1308
1309           /* We used to use comment packets, but not any longer.  In
1310              case we still have comments on a key, strip them here
1311              before we call build_packet(). */
1312           if (node->pkt->pkttype == PKT_COMMENT)
1313             continue;
1314
1315           /* Make sure that ring_trust packets never get exported. */
1316           if (node->pkt->pkttype == PKT_RING_TRUST)
1317             continue;
1318
1319           /* If exact is set, then we only export what was requested
1320              (plus the primary key, if the user didn't specifically
1321              request it). */
1322           if (desc[descindex].exact
1323               && node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
1324             {
1325               if (!exact_subkey_match_p (desc+descindex, node))
1326                 {
1327                   /* Before skipping this subkey, check whether any
1328                      other description wants an exact match on a
1329                      subkey and include that subkey into the output
1330                      too.  Need to add this subkey to a list so that
1331                      it won't get processed a second time.
1332
1333                      So the first step here is to check that list and
1334                      skip in any case if the key is in that list.
1335
1336                      We need this whole mess because the import
1337                      function of GnuPG < 2.1 is not able to merge
1338                      secret keys and thus it is useless to output them
1339                      as two separate keys and have import merge them.  */
1340                   if (subkey_in_list_p (subkey_list, node))
1341                     skip_until_subkey = 1; /* Already processed this one. */
1342                   else
1343                     {
1344                       size_t j;
1345
1346                       for (j=0; j < ndesc; j++)
1347                         if (j != descindex && desc[j].exact
1348                             && exact_subkey_match_p (desc+j, node))
1349                           break;
1350                       if (!(j < ndesc))
1351                         skip_until_subkey = 1; /* No other one matching. */
1352                     }
1353                 }
1354
1355               if(skip_until_subkey)
1356                 continue;
1357
1358               /* Mark this one as processed. */
1359               {
1360                 subkey_list_t tmp = new_subkey_list_item (node);
1361                 tmp->next = subkey_list;
1362                 subkey_list = tmp;
1363               }
1364             }
1365
1366           if (node->pkt->pkttype == PKT_SIGNATURE)
1367             {
1368               /* Do not export packets which are marked as not
1369                  exportable.  */
1370               if (!(options&EXPORT_LOCAL_SIGS)
1371                   && !node->pkt->pkt.signature->flags.exportable)
1372                 continue; /* not exportable */
1373
1374               /* Do not export packets with a "sensitive" revocation
1375                  key unless the user wants us to.  Note that we do
1376                  export these when issuing the actual revocation
1377                  (see revoke.c). */
1378               if (!(options&EXPORT_SENSITIVE_REVKEYS)
1379                   && node->pkt->pkt.signature->revkey)
1380                 {
1381                   int i;
1382
1383                   for (i=0;i<node->pkt->pkt.signature->numrevkeys;i++)
1384                     if ( (node->pkt->pkt.signature->revkey[i].class & 0x40))
1385                       break;
1386
1387                   if (i < node->pkt->pkt.signature->numrevkeys)
1388                     continue;
1389                 }
1390             }
1391
1392           /* Don't export attribs? */
1393           if (!(options&EXPORT_ATTRIBUTES)
1394               && node->pkt->pkttype == PKT_USER_ID
1395               && node->pkt->pkt.user_id->attrib_data )
1396             {
1397               /* Skip until we get to something that is not an attrib
1398                  or a signature on an attrib */
1399               while (kbctx->next && kbctx->next->pkt->pkttype==PKT_SIGNATURE)
1400                 kbctx = kbctx->next;
1401
1402               continue;
1403             }
1404
1405           if (secret && (node->pkt->pkttype == PKT_PUBLIC_KEY
1406                          || node->pkt->pkttype == PKT_PUBLIC_SUBKEY))
1407             {
1408               u32 subkidbuf[2], *subkid;
1409               char *hexgrip, *serialno;
1410
1411               pk = node->pkt->pkt.public_key;
1412               if (node->pkt->pkttype == PKT_PUBLIC_KEY)
1413                 subkid = NULL;
1414               else
1415                 {
1416                   keyid_from_pk (pk, subkidbuf);
1417                   subkid = subkidbuf;
1418                 }
1419
1420               if (pk->seckey_info)
1421                 {
1422                   log_error ("key %s: oops: seckey_info already set"
1423                              " - skipped\n", keystr_with_sub (keyid, subkid));
1424                   skip_until_subkey = 1;
1425                   continue;
1426                 }
1427
1428               err = hexkeygrip_from_pk (pk, &hexgrip);
1429               if (err)
1430                 {
1431                   log_error ("key %s: error computing keygrip: %s"
1432                              " - skipped\n", keystr_with_sub (keyid, subkid),
1433                              gpg_strerror (err));
1434                   skip_until_subkey = 1;
1435                   err = 0;
1436                   continue;
1437                 }
1438
1439               if (secret == 2 && node->pkt->pkttype == PKT_PUBLIC_KEY)
1440                 {
1441                   /* We are asked not to export the secret parts of
1442                      the primary key.  Make up an error code to create
1443                      the stub.  */
1444                   err = GPG_ERR_NOT_FOUND;
1445                   serialno = NULL;
1446                 }
1447               else
1448                 err = agent_get_keyinfo (ctrl, hexgrip, &serialno, NULL);
1449
1450               if ((!err && serialno)
1451                   && secret == 2 && node->pkt->pkttype == PKT_PUBLIC_KEY)
1452                 {
1453                   /* It does not make sense to export a key with its
1454                      primary key on card using a non-key stub.  Thus
1455                      we skip those keys when used with
1456                      --export-secret-subkeys. */
1457                   log_info (_("key %s: key material on-card - skipped\n"),
1458                             keystr_with_sub (keyid, subkid));
1459                   skip_until_subkey = 1;
1460                 }
1461               else if (gpg_err_code (err) == GPG_ERR_NOT_FOUND
1462                        || (!err && serialno))
1463                 {
1464                   /* Create a key stub.  */
1465                   struct seckey_info *ski;
1466                   const char *s;
1467
1468                   pk->seckey_info = ski = xtrycalloc (1, sizeof *ski);
1469                   if (!ski)
1470                     {
1471                       err = gpg_error_from_syserror ();
1472                       xfree (hexgrip);
1473                       goto leave;
1474                     }
1475
1476                   ski->is_protected = 1;
1477                   if (err)
1478                     ski->s2k.mode = 1001; /* GNU dummy (no secret key).  */
1479                   else
1480                     {
1481                       ski->s2k.mode = 1002; /* GNU-divert-to-card.  */
1482                       for (s=serialno; sizeof (ski->ivlen) && *s && s[1];
1483                            ski->ivlen++, s += 2)
1484                         ski->iv[ski->ivlen] = xtoi_2 (s);
1485                     }
1486
1487                   err = build_packet (out, node->pkt);
1488                   if (!err && node->pkt->pkttype == PKT_PUBLIC_KEY)
1489                     {
1490                       stats->exported++;
1491                       print_status_exported (node->pkt->pkt.public_key);
1492                     }
1493                 }
1494               else if (!err)
1495                 {
1496                   err = receive_seckey_from_agent (ctrl, cipherhd,
1497                                                    0, &cache_nonce,
1498                                                    hexgrip, pk);
1499                   if (err)
1500                     {
1501                       if (gpg_err_code (err) == GPG_ERR_FULLY_CANCELED)
1502                         goto leave;
1503                       skip_until_subkey = 1;
1504                       err = 0;
1505                     }
1506                   else
1507                     {
1508                       err = build_packet (out, node->pkt);
1509                       if (node->pkt->pkttype == PKT_PUBLIC_KEY)
1510                         {
1511                           stats->exported++;
1512                           print_status_exported (node->pkt->pkt.public_key);
1513                         }
1514                     }
1515                 }
1516               else
1517                 {
1518                   log_error ("key %s: error getting keyinfo from agent: %s"
1519                              " - skipped\n", keystr_with_sub (keyid, subkid),
1520                              gpg_strerror (err));
1521                   skip_until_subkey = 1;
1522                   err = 0;
1523                 }
1524
1525               xfree (pk->seckey_info);
1526               pk->seckey_info = NULL;
1527               xfree (hexgrip);
1528             }
1529           else
1530             {
1531               err = build_packet (out, node->pkt);
1532               if (!err && node->pkt->pkttype == PKT_PUBLIC_KEY)
1533                 {
1534                   stats->exported++;
1535                   print_status_exported (node->pkt->pkt.public_key);
1536                 }
1537             }
1538
1539
1540           if (err)
1541             {
1542               log_error ("build_packet(%d) failed: %s\n",
1543                          node->pkt->pkttype, gpg_strerror (err));
1544               goto leave;
1545             }
1546
1547           if (!skip_until_subkey)
1548             *any = 1;
1549         }
1550
1551       if (keyblock_out)
1552         {
1553           *keyblock_out = keyblock;
1554           break;
1555         }
1556     }
1557   if (gpg_err_code (err) == GPG_ERR_NOT_FOUND)
1558     err = 0;
1559
1560  leave:
1561   gcry_cipher_close (cipherhd);
1562   release_subkey_list (subkey_list);
1563   xfree(desc);
1564   keydb_release (kdbhd);
1565   if (err || !keyblock_out)
1566     release_kbnode( keyblock );
1567   xfree (cache_nonce);
1568   if( !*any )
1569     log_info(_("WARNING: nothing exported\n"));
1570   return err;
1571 }
1572
1573
1574
1575 \f
1576 static gpg_error_t
1577 key_to_sshblob (membuf_t *mb, const char *identifier, ...)
1578 {
1579   va_list arg_ptr;
1580   gpg_error_t err = 0;
1581   unsigned char nbuf[4];
1582   unsigned char *buf;
1583   size_t buflen;
1584   gcry_mpi_t a;
1585
1586   ulongtobuf (nbuf, (ulong)strlen (identifier));
1587   put_membuf (mb, nbuf, 4);
1588   put_membuf_str (mb, identifier);
1589   if (!strncmp (identifier, "ecdsa-sha2-", 11))
1590     {
1591       ulongtobuf (nbuf, (ulong)strlen (identifier+11));
1592       put_membuf (mb, nbuf, 4);
1593       put_membuf_str (mb, identifier+11);
1594     }
1595   va_start (arg_ptr, identifier);
1596   while ((a = va_arg (arg_ptr, gcry_mpi_t)))
1597     {
1598       err = gcry_mpi_aprint (GCRYMPI_FMT_SSH, &buf, &buflen, a);
1599       if (err)
1600         break;
1601       if (!strcmp (identifier, "ssh-ed25519")
1602           && buflen > 5 && buf[4] == 0x40)
1603         {
1604           /* We need to strip our 0x40 prefix.  */
1605           put_membuf (mb, "\x00\x00\x00\x20", 4);
1606           put_membuf (mb, buf+5, buflen-5);
1607         }
1608       else
1609         put_membuf (mb, buf, buflen);
1610       gcry_free (buf);
1611     }
1612   va_end (arg_ptr);
1613   return err;
1614 }
1615
1616 /* Export the key identified by USERID in the SSH public key format.
1617    The function exports the latest subkey with Authentication
1618    capability unless the '!' suffix is used to export a specific
1619    key.  */
1620 gpg_error_t
1621 export_ssh_key (ctrl_t ctrl, const char *userid)
1622 {
1623   gpg_error_t err;
1624   kbnode_t keyblock = NULL;
1625   KEYDB_SEARCH_DESC desc;
1626   u32 latest_date;
1627   u32 curtime = make_timestamp ();
1628   kbnode_t latest_key, node;
1629   PKT_public_key *pk;
1630   const char *identifier;
1631   membuf_t mb;
1632   estream_t fp = NULL;
1633   struct b64state b64_state;
1634   const char *fname = "-";
1635
1636   init_membuf (&mb, 4096);
1637
1638   /* We need to know whether the key has been specified using the
1639      exact syntax ('!' suffix).  Thus we need to run a
1640      classify_user_id on our own.  */
1641   err = classify_user_id (userid, &desc, 1);
1642
1643   /* Get the public key.  */
1644   if (!err)
1645     {
1646       getkey_ctx_t getkeyctx;
1647
1648       err = get_pubkey_byname (ctrl, &getkeyctx, NULL, userid, &keyblock,
1649                                NULL,
1650                                0  /* Only usable keys or given exact. */,
1651                                1  /* No AKL lookup.  */);
1652       if (!err)
1653         {
1654           err = getkey_next (getkeyctx, NULL, NULL);
1655           if (!err)
1656             err = gpg_error (GPG_ERR_AMBIGUOUS_NAME);
1657           else if (gpg_err_code (err) == GPG_ERR_NO_PUBKEY)
1658             err = 0;
1659         }
1660       getkey_end (getkeyctx);
1661     }
1662   if (err)
1663     {
1664       log_error (_("key \"%s\" not found: %s\n"), userid, gpg_strerror (err));
1665       return err;
1666     }
1667
1668   /* The finish_lookup code in getkey.c does not handle auth keys,
1669      thus we have to duplicate the code here to find the latest
1670      subkey.  However, if the key has been found using an exact match
1671      ('!' notation) we use that key without any further checks and
1672      even allow the use of the primary key. */
1673   latest_date = 0;
1674   latest_key = NULL;
1675   for (node = keyblock; node; node = node->next)
1676     {
1677       if ((node->pkt->pkttype == PKT_PUBLIC_SUBKEY
1678            || node->pkt->pkttype == PKT_PUBLIC_KEY)
1679           && node->pkt->pkt.public_key->flags.exact)
1680         {
1681           latest_key = node;
1682           break;
1683         }
1684     }
1685   if (!latest_key)
1686     {
1687       for (node = keyblock; node; node = node->next)
1688         {
1689           if (node->pkt->pkttype != PKT_PUBLIC_SUBKEY)
1690             continue;
1691
1692           pk = node->pkt->pkt.public_key;
1693           if (DBG_LOOKUP)
1694             log_debug ("\tchecking subkey %08lX\n",
1695                        (ulong) keyid_from_pk (pk, NULL));
1696           if (!(pk->pubkey_usage & PUBKEY_USAGE_AUTH))
1697             {
1698               if (DBG_LOOKUP)
1699                 log_debug ("\tsubkey not usable for authentication\n");
1700               continue;
1701             }
1702           if (!pk->flags.valid)
1703             {
1704               if (DBG_LOOKUP)
1705                 log_debug ("\tsubkey not valid\n");
1706               continue;
1707             }
1708           if (pk->flags.revoked)
1709             {
1710               if (DBG_LOOKUP)
1711                 log_debug ("\tsubkey has been revoked\n");
1712               continue;
1713             }
1714           if (pk->has_expired)
1715             {
1716               if (DBG_LOOKUP)
1717                 log_debug ("\tsubkey has expired\n");
1718               continue;
1719             }
1720           if (pk->timestamp > curtime && !opt.ignore_valid_from)
1721             {
1722               if (DBG_LOOKUP)
1723                 log_debug ("\tsubkey not yet valid\n");
1724               continue;
1725             }
1726           if (DBG_LOOKUP)
1727             log_debug ("\tsubkey might be fine\n");
1728           /* In case a key has a timestamp of 0 set, we make sure that it
1729              is used.  A better change would be to compare ">=" but that
1730              might also change the selected keys and is as such a more
1731              intrusive change.  */
1732           if (pk->timestamp > latest_date || (!pk->timestamp && !latest_date))
1733             {
1734               latest_date = pk->timestamp;
1735               latest_key = node;
1736             }
1737         }
1738     }
1739
1740   if (!latest_key)
1741     {
1742       err = gpg_error (GPG_ERR_UNUSABLE_PUBKEY);
1743       log_error (_("key \"%s\" not found: %s\n"), userid, gpg_strerror (err));
1744       goto leave;
1745     }
1746
1747   pk = latest_key->pkt->pkt.public_key;
1748   if (DBG_LOOKUP)
1749     log_debug ("\tusing key %08lX\n", (ulong) keyid_from_pk (pk, NULL));
1750
1751   switch (pk->pubkey_algo)
1752     {
1753     case PUBKEY_ALGO_DSA:
1754       identifier = "ssh-dss";
1755       err = key_to_sshblob (&mb, identifier,
1756                             pk->pkey[0], pk->pkey[1], pk->pkey[2], pk->pkey[3],
1757                             NULL);
1758       break;
1759
1760     case PUBKEY_ALGO_RSA:
1761     case PUBKEY_ALGO_RSA_S:
1762       identifier = "ssh-rsa";
1763       err = key_to_sshblob (&mb, identifier, pk->pkey[1], pk->pkey[0], NULL);
1764       break;
1765
1766     case PUBKEY_ALGO_ECDSA:
1767       {
1768         char *curveoid;
1769         const char *curve;
1770
1771         curveoid = openpgp_oid_to_str (pk->pkey[0]);
1772         if (!curveoid)
1773           err = gpg_error_from_syserror ();
1774         else if (!(curve = openpgp_oid_to_curve (curveoid, 0)))
1775           err = gpg_error (GPG_ERR_UNKNOWN_CURVE);
1776         else
1777           {
1778             if (!strcmp (curve, "nistp256"))
1779               identifier = "ecdsa-sha2-nistp256";
1780             else if (!strcmp (curve, "nistp384"))
1781               identifier = "ecdsa-sha2-nistp384";
1782             else if (!strcmp (curve, "nistp521"))
1783               identifier = "ecdsa-sha2-nistp521";
1784             else
1785               identifier = NULL;
1786
1787             if (!identifier)
1788               err = gpg_error (GPG_ERR_UNKNOWN_CURVE);
1789             else
1790               err = key_to_sshblob (&mb, identifier, pk->pkey[1], NULL);
1791           }
1792         xfree (curveoid);
1793       }
1794       break;
1795
1796     case PUBKEY_ALGO_EDDSA:
1797       if (!openpgp_oid_is_ed25519 (pk->pkey[0]))
1798         err = gpg_error (GPG_ERR_UNKNOWN_CURVE);
1799       else
1800         {
1801           identifier = "ssh-ed25519";
1802           err = key_to_sshblob (&mb, identifier, pk->pkey[1], NULL);
1803         }
1804       break;
1805
1806     case PUBKEY_ALGO_ELGAMAL_E:
1807     case PUBKEY_ALGO_ELGAMAL:
1808       err = gpg_error (GPG_ERR_UNUSABLE_PUBKEY);
1809       break;
1810
1811     default:
1812       err = GPG_ERR_PUBKEY_ALGO;
1813       break;
1814     }
1815
1816   if (err)
1817     goto leave;
1818
1819   if (opt.outfile && *opt.outfile && strcmp (opt.outfile, "-"))
1820     fp = es_fopen ((fname = opt.outfile), "w");
1821   else
1822     fp = es_stdout;
1823   if (!fp)
1824     {
1825       err = gpg_error_from_syserror ();
1826       log_error (_("error creating '%s': %s\n"), fname, gpg_strerror (err));
1827       goto leave;
1828     }
1829
1830   es_fprintf (fp, "%s ", identifier);
1831   err = b64enc_start_es (&b64_state, fp, "");
1832   if (err)
1833     goto leave;
1834   {
1835     void *blob;
1836     size_t bloblen;
1837
1838     blob = get_membuf (&mb, &bloblen);
1839     if (!blob)
1840       err = gpg_error_from_syserror ();
1841     else
1842       err = b64enc_write (&b64_state, blob, bloblen);
1843     xfree (blob);
1844     if (err)
1845       goto leave;
1846   }
1847   err = b64enc_finish (&b64_state);
1848   if (err)
1849     goto leave;
1850   es_fprintf (fp, " openpgp:0x%08lX\n", (ulong)keyid_from_pk (pk, NULL));
1851
1852   if (es_ferror (fp))
1853     err = gpg_error_from_syserror ();
1854   else
1855     {
1856       if (es_fclose (fp))
1857         err = gpg_error_from_syserror ();
1858       fp = NULL;
1859     }
1860
1861   if (err)
1862     log_error (_("error writing '%s': %s\n"), fname, gpg_strerror (err));
1863
1864  leave:
1865   es_fclose (fp);
1866   xfree (get_membuf (&mb, NULL));
1867   release_kbnode (keyblock);
1868   return err;
1869 }