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