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