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