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