d84ff7459987f83a58b091f781178b4918344d70
[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 /* Export the keys identified by the list of strings in USERS to the
813    stream OUT.  If Secret is false public keys will be exported.  With
814    secret true secret keys will be exported; in this case 1 means the
815    entire secret keyblock and 2 only the subkeys.  OPTIONS are the
816    export options to apply.  If KEYBLOCK_OUT is not NULL, AND the exit
817    code is zero, a pointer to the first keyblock found and exported
818    will be stored at this address; no other keyblocks are exported in
819    this case.  The caller must free the returned keyblock.  If any
820    key has been exported true is stored at ANY. */
821 static int
822 do_export_stream (ctrl_t ctrl, iobuf_t out, strlist_t users, int secret,
823                   kbnode_t *keyblock_out, unsigned int options,
824                   export_stats_t stats, int *any)
825 {
826   gpg_error_t err = 0;
827   PACKET pkt;
828   KBNODE keyblock = NULL;
829   KBNODE kbctx, node;
830   size_t ndesc, descindex;
831   KEYDB_SEARCH_DESC *desc = NULL;
832   subkey_list_t subkey_list = NULL;  /* Track already processed subkeys. */
833   KEYDB_HANDLE kdbhd;
834   strlist_t sl;
835   gcry_cipher_hd_t cipherhd = NULL;
836   char *cache_nonce = NULL;
837   struct export_stats_s dummystats;
838
839   if (!stats)
840     stats = &dummystats;
841   *any = 0;
842   init_packet (&pkt);
843   kdbhd = keydb_new ();
844
845   /* For the DANE format override the options.  */
846   if ((options & EXPORT_DANE_FORMAT))
847     options = (EXPORT_DANE_FORMAT | EXPORT_MINIMAL | EXPORT_CLEAN);
848
849
850   if (!users)
851     {
852       ndesc = 1;
853       desc = xcalloc (ndesc, sizeof *desc);
854       desc[0].mode = KEYDB_SEARCH_MODE_FIRST;
855     }
856   else
857     {
858       for (ndesc=0, sl=users; sl; sl = sl->next, ndesc++)
859         ;
860       desc = xmalloc ( ndesc * sizeof *desc);
861
862       for (ndesc=0, sl=users; sl; sl = sl->next)
863         {
864           if (!(err=classify_user_id (sl->d, desc+ndesc, 1)))
865             ndesc++;
866           else
867             log_error (_("key \"%s\" not found: %s\n"),
868                        sl->d, gpg_strerror (err));
869         }
870
871       keydb_disable_caching (kdbhd);  /* We are looping the search.  */
872
873       /* It would be nice to see which of the given users did actually
874          match one in the keyring.  To implement this we need to have
875          a found flag for each entry in desc.  To set this flag we
876          must check all those entries after a match to mark all
877          matched one - currently we stop at the first match.  To do
878          this we need an extra flag to enable this feature.  */
879     }
880
881 #ifdef ENABLE_SELINUX_HACKS
882   if (secret)
883     {
884       log_error (_("exporting secret keys not allowed\n"));
885       err = gpg_error (GPG_ERR_NOT_SUPPORTED);
886       goto leave;
887     }
888 #endif
889
890   /* For secret key export we need to setup a decryption context.  */
891   if (secret)
892     {
893       void *kek = NULL;
894       size_t keklen;
895
896       err = agent_keywrap_key (ctrl, 1, &kek, &keklen);
897       if (err)
898         {
899           log_error ("error getting the KEK: %s\n", gpg_strerror (err));
900           goto leave;
901         }
902
903       /* Prepare a cipher context.  */
904       err = gcry_cipher_open (&cipherhd, GCRY_CIPHER_AES128,
905                               GCRY_CIPHER_MODE_AESWRAP, 0);
906       if (!err)
907         err = gcry_cipher_setkey (cipherhd, kek, keklen);
908       if (err)
909         {
910           log_error ("error setting up an encryption context: %s\n",
911                      gpg_strerror (err));
912           goto leave;
913         }
914       xfree (kek);
915       kek = NULL;
916     }
917
918   for (;;)
919     {
920       int skip_until_subkey = 0;
921       u32 keyid[2];
922       PKT_public_key *pk;
923
924       err = keydb_search (kdbhd, desc, ndesc, &descindex);
925       if (!users)
926         desc[0].mode = KEYDB_SEARCH_MODE_NEXT;
927       if (gpg_err_code (err) == GPG_ERR_LEGACY_KEY)
928         continue;  /* Skip PGP2 keys.  */
929       if (err)
930         break;
931
932       /* Read the keyblock. */
933       release_kbnode (keyblock);
934       keyblock = NULL;
935       err = keydb_get_keyblock (kdbhd, &keyblock);
936       if (gpg_err_code (err) == GPG_ERR_LEGACY_KEY)
937         continue;  /* Skip PGP2 keys.  */
938       if (err)
939         {
940           log_error (_("error reading keyblock: %s\n"), gpg_strerror (err));
941           goto leave;
942         }
943
944       node = find_kbnode (keyblock, PKT_PUBLIC_KEY);
945       if (!node)
946         {
947           log_error ("public key packet not found in keyblock - skipped\n");
948           continue;
949         }
950       stats->count++;
951       setup_main_keyids (keyblock);  /* gpg_format_keydesc needs it.  */
952       pk = node->pkt->pkt.public_key;
953       keyid_from_pk (pk, keyid);
954
955       /* If a secret key export is required we need to check whether
956          we have a secret key at all and if so create the seckey_info
957          structure.  */
958       if (secret)
959         {
960           if (agent_probe_any_secret_key (ctrl, keyblock))
961             continue;  /* No secret key (neither primary nor subkey).  */
962
963           /* No v3 keys with GNU mode 1001. */
964           if (secret == 2 && pk->version == 3)
965             {
966               log_info (_("key %s: PGP 2.x style key - skipped\n"),
967                         keystr (keyid));
968               continue;
969             }
970
971           /* The agent does not yet allow to export v3 packets.  It is
972              actually questionable whether we should allow them at
973              all.  */
974           if (pk->version == 3)
975             {
976               log_info ("key %s: PGP 2.x style key (v3) export "
977                         "not yet supported - skipped\n", keystr (keyid));
978               continue;
979             }
980           stats->secret_count++;
981         }
982
983       /* Always do the cleaning on the public key part if requested.
984          Note that we don't yet set this option if we are exporting
985          secret keys.  Note that both export-clean and export-minimal
986          only apply to UID sigs (0x10, 0x11, 0x12, and 0x13).  A
987          designated revocation is never stripped, even with
988          export-minimal set.  */
989       if ((options & EXPORT_CLEAN))
990         clean_key (keyblock, opt.verbose, (options&EXPORT_MINIMAL), NULL, NULL);
991
992       /* And write it. */
993       xfree (cache_nonce);
994       cache_nonce = NULL;
995       for (kbctx=NULL; (node = walk_kbnode (keyblock, &kbctx, 0)); )
996         {
997           if (skip_until_subkey)
998             {
999               if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
1000                 skip_until_subkey = 0;
1001               else
1002                 continue;
1003             }
1004
1005           /* We used to use comment packets, but not any longer.  In
1006              case we still have comments on a key, strip them here
1007              before we call build_packet(). */
1008           if (node->pkt->pkttype == PKT_COMMENT)
1009             continue;
1010
1011           /* Make sure that ring_trust packets never get exported. */
1012           if (node->pkt->pkttype == PKT_RING_TRUST)
1013             continue;
1014
1015           /* If exact is set, then we only export what was requested
1016              (plus the primary key, if the user didn't specifically
1017              request it). */
1018           if (desc[descindex].exact
1019               && node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
1020             {
1021               if (!exact_subkey_match_p (desc+descindex, node))
1022                 {
1023                   /* Before skipping this subkey, check whether any
1024                      other description wants an exact match on a
1025                      subkey and include that subkey into the output
1026                      too.  Need to add this subkey to a list so that
1027                      it won't get processed a second time.
1028
1029                      So the first step here is to check that list and
1030                      skip in any case if the key is in that list.
1031
1032                      We need this whole mess because the import
1033                      function of GnuPG < 2.1 is not able to merge
1034                      secret keys and thus it is useless to output them
1035                      as two separate keys and have import merge them.  */
1036                   if (subkey_in_list_p (subkey_list, node))
1037                     skip_until_subkey = 1; /* Already processed this one. */
1038                   else
1039                     {
1040                       size_t j;
1041
1042                       for (j=0; j < ndesc; j++)
1043                         if (j != descindex && desc[j].exact
1044                             && exact_subkey_match_p (desc+j, node))
1045                           break;
1046                       if (!(j < ndesc))
1047                         skip_until_subkey = 1; /* No other one matching. */
1048                     }
1049                 }
1050
1051               if(skip_until_subkey)
1052                 continue;
1053
1054               /* Mark this one as processed. */
1055               {
1056                 subkey_list_t tmp = new_subkey_list_item (node);
1057                 tmp->next = subkey_list;
1058                 subkey_list = tmp;
1059               }
1060             }
1061
1062           if (node->pkt->pkttype == PKT_SIGNATURE)
1063             {
1064               /* Do not export packets which are marked as not
1065                  exportable.  */
1066               if (!(options&EXPORT_LOCAL_SIGS)
1067                   && !node->pkt->pkt.signature->flags.exportable)
1068                 continue; /* not exportable */
1069
1070               /* Do not export packets with a "sensitive" revocation
1071                  key unless the user wants us to.  Note that we do
1072                  export these when issuing the actual revocation
1073                  (see revoke.c). */
1074               if (!(options&EXPORT_SENSITIVE_REVKEYS)
1075                   && node->pkt->pkt.signature->revkey)
1076                 {
1077                   int i;
1078
1079                   for (i=0;i<node->pkt->pkt.signature->numrevkeys;i++)
1080                     if ( (node->pkt->pkt.signature->revkey[i].class & 0x40))
1081                       break;
1082
1083                   if (i < node->pkt->pkt.signature->numrevkeys)
1084                     continue;
1085                 }
1086             }
1087
1088           /* Don't export attribs? */
1089           if (!(options&EXPORT_ATTRIBUTES)
1090               && node->pkt->pkttype == PKT_USER_ID
1091               && node->pkt->pkt.user_id->attrib_data )
1092             {
1093               /* Skip until we get to something that is not an attrib
1094                  or a signature on an attrib */
1095               while (kbctx->next && kbctx->next->pkt->pkttype==PKT_SIGNATURE)
1096                 kbctx = kbctx->next;
1097
1098               continue;
1099             }
1100
1101           if (secret && (node->pkt->pkttype == PKT_PUBLIC_KEY
1102                          || node->pkt->pkttype == PKT_PUBLIC_SUBKEY))
1103             {
1104               u32 subkidbuf[2], *subkid;
1105               char *hexgrip, *serialno;
1106
1107               pk = node->pkt->pkt.public_key;
1108               if (node->pkt->pkttype == PKT_PUBLIC_KEY)
1109                 subkid = NULL;
1110               else
1111                 {
1112                   keyid_from_pk (pk, subkidbuf);
1113                   subkid = subkidbuf;
1114                 }
1115
1116               if (pk->seckey_info)
1117                 {
1118                   log_error ("key %s: oops: seckey_info already set"
1119                              " - skipped\n", keystr_with_sub (keyid, subkid));
1120                   skip_until_subkey = 1;
1121                   continue;
1122                 }
1123
1124               err = hexkeygrip_from_pk (pk, &hexgrip);
1125               if (err)
1126                 {
1127                   log_error ("key %s: error computing keygrip: %s"
1128                              " - skipped\n", keystr_with_sub (keyid, subkid),
1129                              gpg_strerror (err));
1130                   skip_until_subkey = 1;
1131                   err = 0;
1132                   continue;
1133                 }
1134
1135               if (secret == 2 && node->pkt->pkttype == PKT_PUBLIC_KEY)
1136                 {
1137                   /* We are asked not to export the secret parts of
1138                      the primary key.  Make up an error code to create
1139                      the stub.  */
1140                   err = GPG_ERR_NOT_FOUND;
1141                   serialno = NULL;
1142                 }
1143               else
1144                 err = agent_get_keyinfo (ctrl, hexgrip, &serialno);
1145
1146               if ((!err && serialno)
1147                   && secret == 2 && node->pkt->pkttype == PKT_PUBLIC_KEY)
1148                 {
1149                   /* It does not make sense to export a key with its
1150                      primary key on card using a non-key stub.  Thus
1151                      we skip those keys when used with
1152                      --export-secret-subkeys. */
1153                   log_info (_("key %s: key material on-card - skipped\n"),
1154                             keystr_with_sub (keyid, subkid));
1155                   skip_until_subkey = 1;
1156                 }
1157               else if (gpg_err_code (err) == GPG_ERR_NOT_FOUND
1158                        || (!err && serialno))
1159                 {
1160                   /* Create a key stub.  */
1161                   struct seckey_info *ski;
1162                   const char *s;
1163
1164                   pk->seckey_info = ski = xtrycalloc (1, sizeof *ski);
1165                   if (!ski)
1166                     {
1167                       err = gpg_error_from_syserror ();
1168                       xfree (hexgrip);
1169                       goto leave;
1170                     }
1171
1172                   ski->is_protected = 1;
1173                   if (err)
1174                     ski->s2k.mode = 1001; /* GNU dummy (no secret key).  */
1175                   else
1176                     {
1177                       ski->s2k.mode = 1002; /* GNU-divert-to-card.  */
1178                       for (s=serialno; sizeof (ski->ivlen) && *s && s[1];
1179                            ski->ivlen++, s += 2)
1180                         ski->iv[ski->ivlen] = xtoi_2 (s);
1181                     }
1182
1183                   err = build_packet (out, node->pkt);
1184                   if (!err && node->pkt->pkttype == PKT_PUBLIC_KEY)
1185                     stats->exported++;
1186                 }
1187               else if (!err)
1188                 {
1189                   /* FIXME: Move this spaghetti code into a separate
1190                      function.  */
1191                   unsigned char *wrappedkey = NULL;
1192                   size_t wrappedkeylen;
1193                   unsigned char *key = NULL;
1194                   size_t keylen, realkeylen;
1195                   gcry_sexp_t s_skey;
1196
1197                   if (opt.verbose)
1198                     log_info ("key %s: asking agent for the secret parts\n",
1199                               keystr_with_sub (keyid, subkid));
1200
1201                   {
1202                     char *prompt = gpg_format_keydesc (pk,
1203                                                        FORMAT_KEYDESC_EXPORT,1);
1204                     err = agent_export_key (ctrl, hexgrip, prompt, &cache_nonce,
1205                                             &wrappedkey, &wrappedkeylen);
1206                     xfree (prompt);
1207                   }
1208                   if (err)
1209                     goto unwraperror;
1210                   if (wrappedkeylen < 24)
1211                     {
1212                       err = gpg_error (GPG_ERR_INV_LENGTH);
1213                       goto unwraperror;
1214                     }
1215                   keylen = wrappedkeylen - 8;
1216                   key = xtrymalloc_secure (keylen);
1217                   if (!key)
1218                     {
1219                       err = gpg_error_from_syserror ();
1220                       goto unwraperror;
1221                     }
1222                   err = gcry_cipher_decrypt (cipherhd, key, keylen,
1223                                              wrappedkey, wrappedkeylen);
1224                   if (err)
1225                     goto unwraperror;
1226                   realkeylen = gcry_sexp_canon_len (key, keylen, NULL, &err);
1227                   if (!realkeylen)
1228                     goto unwraperror; /* Invalid csexp.  */
1229
1230                   err = gcry_sexp_sscan (&s_skey, NULL, key, realkeylen);
1231                   xfree (key);
1232                   key = NULL;
1233                   if (err)
1234                     goto unwraperror;
1235                   err = transfer_format_to_openpgp (s_skey, pk);
1236                   gcry_sexp_release (s_skey);
1237                   if (err)
1238                     goto unwraperror;
1239
1240                   err = build_packet (out, node->pkt);
1241                   if (!err && node->pkt->pkttype == PKT_PUBLIC_KEY)
1242                     stats->exported++;
1243                   goto unwraperror_leave;
1244
1245                 unwraperror:
1246                   xfree (wrappedkey);
1247                   xfree (key);
1248                   if (err)
1249                     {
1250                       log_error ("key %s: error receiving key from agent:"
1251                                  " %s%s\n",
1252                                  keystr_with_sub (keyid, subkid),
1253                                  gpg_strerror (err),
1254                                  gpg_err_code (err) == GPG_ERR_FULLY_CANCELED?
1255                                  "":_(" - skipped"));
1256                       if (gpg_err_code (err) == GPG_ERR_FULLY_CANCELED)
1257                         goto leave;
1258                       skip_until_subkey = 1;
1259                       err = 0;
1260                     }
1261                 unwraperror_leave:
1262                   ;
1263                 }
1264               else
1265                 {
1266                   log_error ("key %s: error getting keyinfo from agent: %s"
1267                              " - skipped\n", keystr_with_sub (keyid, subkid),
1268                              gpg_strerror (err));
1269                   skip_until_subkey = 1;
1270                   err = 0;
1271                 }
1272
1273               xfree (pk->seckey_info);
1274               pk->seckey_info = NULL;
1275               xfree (hexgrip);
1276             }
1277           else
1278             {
1279               err = build_packet (out, node->pkt);
1280               if (!err && node->pkt->pkttype == PKT_PUBLIC_KEY)
1281                 stats->exported++;
1282             }
1283
1284
1285           if (err)
1286             {
1287               log_error ("build_packet(%d) failed: %s\n",
1288                          node->pkt->pkttype, gpg_strerror (err));
1289               goto leave;
1290             }
1291
1292           if (!skip_until_subkey)
1293             *any = 1;
1294         }
1295
1296       if (keyblock_out)
1297         {
1298           *keyblock_out = keyblock;
1299           break;
1300         }
1301     }
1302   if (gpg_err_code (err) == GPG_ERR_NOT_FOUND)
1303     err = 0;
1304
1305  leave:
1306   gcry_cipher_close (cipherhd);
1307   release_subkey_list (subkey_list);
1308   xfree(desc);
1309   keydb_release (kdbhd);
1310   if (err || !keyblock_out)
1311     release_kbnode( keyblock );
1312   xfree (cache_nonce);
1313   if( !*any )
1314     log_info(_("WARNING: nothing exported\n"));
1315   return err;
1316 }