gpg: Split a too large export function.
[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-2016  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
28 #include "gpg.h"
29 #include "options.h"
30 #include "packet.h"
31 #include "status.h"
32 #include "keydb.h"
33 #include "util.h"
34 #include "main.h"
35 #include "i18n.h"
36 #include "membuf.h"
37 #include "host2net.h"
38 #include "recsel.h"
39 #include "mbox-util.h"
40 #include "init.h"
41 #include "trustdb.h"
42 #include "call-agent.h"
43
44 /* An object to keep track of subkeys. */
45 struct subkey_list_s
46 {
47   struct subkey_list_s *next;
48   u32 kid[2];
49 };
50 typedef struct subkey_list_s *subkey_list_t;
51
52
53 /* An object to track statistics for export operations.  */
54 struct export_stats_s
55 {
56   ulong count;            /* Number of processed keys.        */
57   ulong secret_count;     /* Number of secret keys seen.      */
58   ulong exported;         /* Number of actual exported keys.  */
59 };
60
61
62 /* A global variable to store the selector created from
63  * --export-filter keep-uid=EXPR.
64  *
65  * FIXME: We should put this into the CTRL object but that requires a
66  * lot more changes right now.
67  */
68 static recsel_expr_t export_keep_uid;
69
70
71
72 /* Local prototypes.  */
73 static int do_export (ctrl_t ctrl, strlist_t users, int secret,
74                       unsigned int options, export_stats_t stats);
75 static int do_export_stream (ctrl_t ctrl, iobuf_t out,
76                              strlist_t users, int secret,
77                              kbnode_t *keyblock_out, unsigned int options,
78                              export_stats_t stats, int *any);
79
80 \f
81 static void
82 cleanup_export_globals (void)
83 {
84   recsel_release (export_keep_uid);
85   export_keep_uid = NULL;
86 }
87
88
89 /* Option parser for export options.  See parse_options fro
90    details.  */
91 int
92 parse_export_options(char *str,unsigned int *options,int noisy)
93 {
94   struct parse_options export_opts[]=
95     {
96       {"export-local-sigs",EXPORT_LOCAL_SIGS,NULL,
97        N_("export signatures that are marked as local-only")},
98       {"export-attributes",EXPORT_ATTRIBUTES,NULL,
99        N_("export attribute user IDs (generally photo IDs)")},
100       {"export-sensitive-revkeys",EXPORT_SENSITIVE_REVKEYS,NULL,
101        N_("export revocation keys marked as \"sensitive\"")},
102       {"export-clean",EXPORT_CLEAN,NULL,
103        N_("remove unusable parts from key during export")},
104       {"export-minimal",EXPORT_MINIMAL|EXPORT_CLEAN,NULL,
105        N_("remove as much as possible from key during export")},
106       /* Aliases for backward compatibility */
107       {"include-local-sigs",EXPORT_LOCAL_SIGS,NULL,NULL},
108       {"include-attributes",EXPORT_ATTRIBUTES,NULL,NULL},
109       {"include-sensitive-revkeys",EXPORT_SENSITIVE_REVKEYS,NULL,NULL},
110       /* dummy */
111       {"export-unusable-sigs",0,NULL,NULL},
112       {"export-clean-sigs",0,NULL,NULL},
113       {"export-clean-uids",0,NULL,NULL},
114       {NULL,0,NULL,NULL}
115       /* add tags for include revoked and disabled? */
116     };
117
118   return parse_options(str,options,export_opts,noisy);
119 }
120
121
122 /* Parse and set an export filter from string.  STRING has the format
123  * "NAME=EXPR" with NAME being the name of the filter.  Spaces before
124  * and after NAME are not allowed.  If this function is called several
125  * times all expressions for the same NAME are concatenated.
126  * Supported filter names are:
127  *
128  *  - keep-uid :: If the expression evaluates to true for a certain
129  *                user ID packet, that packet and all it dependencies
130  *                will be exported.  The expression may use these
131  *                variables:
132  *
133  *                - uid  :: The entire user ID.
134  *                - mbox :: The mail box part of the user ID.
135  *                - primary :: Evaluate to true for the primary user ID.
136  */
137 gpg_error_t
138 parse_and_set_export_filter (const char *string)
139 {
140   gpg_error_t err;
141
142   /* Auto register the cleanup function.  */
143   register_mem_cleanup_func (cleanup_export_globals);
144
145   if (!strncmp (string, "keep-uid=", 9))
146     err = recsel_parse_expr (&export_keep_uid, string+9);
147   else
148     err = gpg_error (GPG_ERR_INV_NAME);
149
150   return err;
151 }
152
153
154 /* Create a new export stats object initialized to zero.  On error
155    returns NULL and sets ERRNO.  */
156 export_stats_t
157 export_new_stats (void)
158 {
159   export_stats_t stats;
160
161   return xtrycalloc (1, sizeof *stats);
162 }
163
164
165 /* Release an export stats object.  */
166 void
167 export_release_stats (export_stats_t stats)
168 {
169   xfree (stats);
170 }
171
172
173 /* Print export statistics using the status interface.  */
174 void
175 export_print_stats (export_stats_t stats)
176 {
177   if (!stats)
178     return;
179
180   if (is_status_enabled ())
181     {
182       char buf[15*20];
183
184       snprintf (buf, sizeof buf, "%lu %lu %lu",
185                 stats->count,
186                 stats->secret_count,
187                 stats->exported );
188       write_status_text (STATUS_EXPORT_RES, buf);
189     }
190 }
191
192
193 /*
194  * Export public keys (to stdout or to --output FILE).
195  *
196  * Depending on opt.armor the output is armored.  OPTIONS are defined
197  * in main.h.  If USERS is NULL, all keys will be exported.  STATS is
198  * either an export stats object for update or NULL.
199  *
200  * This function is the core of "gpg --export".
201  */
202 int
203 export_pubkeys (ctrl_t ctrl, strlist_t users, unsigned int options,
204                 export_stats_t stats)
205 {
206   return do_export (ctrl, users, 0, options, stats);
207 }
208
209
210 /*
211  * Export secret keys (to stdout or to --output FILE).
212  *
213  * Depending on opt.armor the output is armored.  If USERS is NULL,
214  * all secret keys will be exported.  STATS is either an export stats
215  * object for update or NULL.
216  *
217  * This function is the core of "gpg --export-secret-keys".
218  */
219 int
220 export_seckeys (ctrl_t ctrl, strlist_t users, export_stats_t stats)
221 {
222   return do_export (ctrl, users, 1, 0, stats);
223 }
224
225
226 /*
227  * Export secret sub keys (to stdout or to --output FILE).
228  *
229  * This is the same as export_seckeys but replaces the primary key by
230  * a stub key.  Depending on opt.armor the output is armored.  If
231  * USERS is NULL, all secret subkeys will be exported.  STATS is
232  * either an export stats object for update or NULL.
233  *
234  * This function is the core of "gpg --export-secret-subkeys".
235  */
236 int
237 export_secsubkeys (ctrl_t ctrl, strlist_t users, export_stats_t stats)
238 {
239   return do_export (ctrl, users, 2, 0, stats);
240 }
241
242
243 /*
244  * Export a single key into a memory buffer.  STATS is either an
245  * export stats object for update or NULL.
246  */
247 gpg_error_t
248 export_pubkey_buffer (ctrl_t ctrl, const char *keyspec, unsigned int options,
249                       export_stats_t stats,
250                       kbnode_t *r_keyblock, void **r_data, size_t *r_datalen)
251 {
252   gpg_error_t err;
253   iobuf_t iobuf;
254   int any;
255   strlist_t helplist;
256
257   *r_keyblock = NULL;
258   *r_data = NULL;
259   *r_datalen = 0;
260
261   helplist = NULL;
262   if (!add_to_strlist_try (&helplist, keyspec))
263     return gpg_error_from_syserror ();
264
265   iobuf = iobuf_temp ();
266   err = do_export_stream (ctrl, iobuf, helplist, 0, r_keyblock, options,
267                           stats, &any);
268   if (!err && !any)
269     err = gpg_error (GPG_ERR_NOT_FOUND);
270   if (!err)
271     {
272       const void *src;
273       size_t datalen;
274
275       iobuf_flush_temp (iobuf);
276       src = iobuf_get_temp_buffer (iobuf);
277       datalen = iobuf_get_temp_length (iobuf);
278       if (!datalen)
279         err = gpg_error (GPG_ERR_NO_PUBKEY);
280       else if (!(*r_data = xtrymalloc (datalen)))
281         err = gpg_error_from_syserror ();
282       else
283         {
284           memcpy (*r_data, src, datalen);
285           *r_datalen = datalen;
286         }
287     }
288   iobuf_close (iobuf);
289   free_strlist (helplist);
290   if (err && *r_keyblock)
291     {
292       release_kbnode (*r_keyblock);
293       *r_keyblock = NULL;
294     }
295   return err;
296 }
297
298
299 /* Export the keys identified by the list of strings in USERS.  If
300    Secret is false public keys will be exported.  With secret true
301    secret keys will be exported; in this case 1 means the entire
302    secret keyblock and 2 only the subkeys.  OPTIONS are the export
303    options to apply.  */
304 static int
305 do_export (ctrl_t ctrl, strlist_t users, int secret, unsigned int options,
306            export_stats_t stats)
307 {
308   IOBUF out = NULL;
309   int any, rc;
310   armor_filter_context_t *afx = NULL;
311   compress_filter_context_t zfx;
312
313   memset( &zfx, 0, sizeof zfx);
314
315   rc = open_outfile (-1, NULL, 0, !!secret, &out );
316   if (rc)
317     return rc;
318
319   if ( opt.armor )
320     {
321       afx = new_armor_context ();
322       afx->what = secret? 5 : 1;
323       push_armor_filter (afx, out);
324     }
325
326   rc = do_export_stream (ctrl, out, users, secret, NULL, options, stats, &any);
327
328   if ( rc || !any )
329     iobuf_cancel (out);
330   else
331     iobuf_close (out);
332   release_armor_context (afx);
333   return rc;
334 }
335
336
337
338 /* Release an entire subkey list. */
339 static void
340 release_subkey_list (subkey_list_t list)
341 {
342   while (list)
343     {
344       subkey_list_t tmp = list->next;;
345       xfree (list);
346       list = tmp;
347     }
348 }
349
350
351 /* Returns true if NODE is a subkey and contained in LIST. */
352 static int
353 subkey_in_list_p (subkey_list_t list, KBNODE node)
354 {
355   if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY
356       || node->pkt->pkttype == PKT_SECRET_SUBKEY )
357     {
358       u32 kid[2];
359
360       keyid_from_pk (node->pkt->pkt.public_key, kid);
361
362       for (; list; list = list->next)
363         if (list->kid[0] == kid[0] && list->kid[1] == kid[1])
364           return 1;
365     }
366   return 0;
367 }
368
369 /* Allocate a new subkey list item from NODE. */
370 static subkey_list_t
371 new_subkey_list_item (KBNODE node)
372 {
373   subkey_list_t list = xcalloc (1, sizeof *list);
374
375   if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY
376       || node->pkt->pkttype == PKT_SECRET_SUBKEY)
377     keyid_from_pk (node->pkt->pkt.public_key, list->kid);
378
379   return list;
380 }
381
382
383 /* Helper function to check whether the subkey at NODE actually
384    matches the description at DESC.  The function returns true if the
385    key under question has been specified by an exact specification
386    (keyID or fingerprint) and does match the one at NODE.  It is
387    assumed that the packet at NODE is either a public or secret
388    subkey. */
389 static int
390 exact_subkey_match_p (KEYDB_SEARCH_DESC *desc, KBNODE node)
391 {
392   u32 kid[2];
393   byte fpr[MAX_FINGERPRINT_LEN];
394   size_t fprlen;
395   int result = 0;
396
397   switch(desc->mode)
398     {
399     case KEYDB_SEARCH_MODE_SHORT_KID:
400     case KEYDB_SEARCH_MODE_LONG_KID:
401       keyid_from_pk (node->pkt->pkt.public_key, kid);
402       break;
403
404     case KEYDB_SEARCH_MODE_FPR16:
405     case KEYDB_SEARCH_MODE_FPR20:
406     case KEYDB_SEARCH_MODE_FPR:
407       fingerprint_from_pk (node->pkt->pkt.public_key, fpr,&fprlen);
408       break;
409
410     default:
411       break;
412     }
413
414   switch(desc->mode)
415     {
416     case KEYDB_SEARCH_MODE_SHORT_KID:
417       if (desc->u.kid[1] == kid[1])
418         result = 1;
419       break;
420
421     case KEYDB_SEARCH_MODE_LONG_KID:
422       if (desc->u.kid[0] == kid[0] && desc->u.kid[1] == kid[1])
423         result = 1;
424       break;
425
426     case KEYDB_SEARCH_MODE_FPR16:
427       if (!memcmp (desc->u.fpr, fpr, 16))
428         result = 1;
429       break;
430
431     case KEYDB_SEARCH_MODE_FPR20:
432     case KEYDB_SEARCH_MODE_FPR:
433       if (!memcmp (desc->u.fpr, fpr, 20))
434         result = 1;
435       break;
436
437     default:
438       break;
439     }
440
441   return result;
442 }
443
444
445 /* Return an error if the key represented by the S-expression S_KEY
446  * and the OpenPGP key represented by PK do not use the same curve. */
447 static gpg_error_t
448 match_curve_skey_pk (gcry_sexp_t s_key, PKT_public_key *pk)
449 {
450   gcry_sexp_t curve = NULL;
451   gcry_sexp_t flags = NULL;
452   char *curve_str = NULL;
453   char *flag;
454   const char *oidstr = NULL;
455   gcry_mpi_t curve_as_mpi = NULL;
456   gpg_error_t err;
457   int is_eddsa = 0;
458   int idx = 0;
459
460   if (!(pk->pubkey_algo==PUBKEY_ALGO_ECDH
461         || pk->pubkey_algo==PUBKEY_ALGO_ECDSA
462         || pk->pubkey_algo==PUBKEY_ALGO_EDDSA))
463     return gpg_error (GPG_ERR_PUBKEY_ALGO);
464
465   curve = gcry_sexp_find_token (s_key, "curve", 0);
466   if (!curve)
467     {
468       log_error ("no reported curve\n");
469       return gpg_error (GPG_ERR_UNKNOWN_CURVE);
470     }
471   curve_str = gcry_sexp_nth_string (curve, 1);
472   gcry_sexp_release (curve); curve = NULL;
473   if (!curve_str)
474     {
475       log_error ("no curve name\n");
476       return gpg_error (GPG_ERR_UNKNOWN_CURVE);
477     }
478   oidstr = openpgp_curve_to_oid (curve_str, NULL);
479   if (!oidstr)
480     {
481       log_error ("no OID known for curve '%s'\n", curve_str);
482       xfree (curve_str);
483       return gpg_error (GPG_ERR_UNKNOWN_CURVE);
484     }
485   xfree (curve_str);
486   err = openpgp_oid_from_str (oidstr, &curve_as_mpi);
487   if (err)
488     return err;
489   if (gcry_mpi_cmp (pk->pkey[0], curve_as_mpi))
490     {
491       log_error ("curves do not match\n");
492       gcry_mpi_release (curve_as_mpi);
493       return gpg_error (GPG_ERR_INV_CURVE);
494     }
495   gcry_mpi_release (curve_as_mpi);
496   flags = gcry_sexp_find_token (s_key, "flags", 0);
497   if (flags)
498     {
499       for (idx = 1; idx < gcry_sexp_length (flags); idx++)
500         {
501           flag = gcry_sexp_nth_string (flags, idx);
502           if (flag && (strcmp ("eddsa", flag) == 0))
503             is_eddsa = 1;
504           gcry_free (flag);
505         }
506     }
507   if (is_eddsa != (pk->pubkey_algo == PUBKEY_ALGO_EDDSA))
508     {
509       log_error ("disagreement about EdDSA\n");
510       err = gpg_error (GPG_ERR_INV_CURVE);
511     }
512
513   return err;
514 }
515
516
517 /* Return a canonicalized public key algoithms.  This is used to
518    compare different flavors of algorithms (e.g. ELG and ELG_E are
519    considered the same).  */
520 static enum gcry_pk_algos
521 canon_pk_algo (enum gcry_pk_algos algo)
522 {
523   switch (algo)
524     {
525     case GCRY_PK_RSA:
526     case GCRY_PK_RSA_E:
527     case GCRY_PK_RSA_S: return GCRY_PK_RSA;
528     case GCRY_PK_ELG:
529     case GCRY_PK_ELG_E: return GCRY_PK_ELG;
530     case GCRY_PK_ECC:
531     case GCRY_PK_ECDSA:
532     case GCRY_PK_ECDH: return GCRY_PK_ECC;
533     default: return algo;
534     }
535 }
536
537
538 /* Take a cleartext dump of a secret key in PK and change the
539  * parameter array in PK to include the secret parameters.  */
540 static gpg_error_t
541 cleartext_secret_key_to_openpgp (gcry_sexp_t s_key, PKT_public_key *pk)
542 {
543   gpg_error_t err = gpg_error (GPG_ERR_NOT_IMPLEMENTED);
544   gcry_sexp_t top_list;
545   gcry_sexp_t key = NULL;
546   char *key_type = NULL;
547   enum gcry_pk_algos pk_algo;
548   struct seckey_info *ski;
549   int idx, sec_start;
550   gcry_mpi_t pub_params[10] = { NULL };
551
552   /* we look for a private-key, then the first element in it tells us
553      the type */
554   top_list = gcry_sexp_find_token (s_key, "private-key", 0);
555   if (!top_list)
556     goto bad_seckey;
557   if (gcry_sexp_length(top_list) != 2)
558     goto bad_seckey;
559   key = gcry_sexp_nth (top_list, 1);
560   if (!key)
561     goto bad_seckey;
562   key_type = gcry_sexp_nth_string(key, 0);
563   pk_algo = gcry_pk_map_name (key_type);
564
565   log_assert (!pk->seckey_info);
566
567   pk->seckey_info = ski = xtrycalloc (1, sizeof *ski);
568   if (!ski)
569     {
570       err = gpg_error_from_syserror ();
571       goto leave;
572     }
573
574   switch (canon_pk_algo (pk_algo))
575     {
576     case GCRY_PK_RSA:
577       if (!is_RSA (pk->pubkey_algo))
578         goto bad_pubkey_algo;
579       err = gcry_sexp_extract_param (key, NULL, "ne",
580                                      &pub_params[0],
581                                      &pub_params[1],
582                                      NULL);
583       for (idx=0; idx < 2 && !err; idx++)
584         if (gcry_mpi_cmp(pk->pkey[idx], pub_params[idx]))
585           err = gpg_error (GPG_ERR_BAD_PUBKEY);
586       if (!err)
587         {
588           for (idx = 2; idx < 6 && !err; idx++)
589             {
590               gcry_mpi_release (pk->pkey[idx]);
591               pk->pkey[idx] = NULL;
592             }
593           err = gcry_sexp_extract_param (key, NULL, "dpqu",
594                                          &pk->pkey[2],
595                                          &pk->pkey[3],
596                                          &pk->pkey[4],
597                                          &pk->pkey[5],
598                                          NULL);
599         }
600       if (!err)
601         {
602           for (idx = 2; idx < 6; idx++)
603             ski->csum += checksum_mpi (pk->pkey[idx]);
604         }
605       break;
606
607     case GCRY_PK_DSA:
608       if (!is_DSA (pk->pubkey_algo))
609         goto bad_pubkey_algo;
610       err = gcry_sexp_extract_param (key, NULL, "pqgy",
611                                      &pub_params[0],
612                                      &pub_params[1],
613                                      &pub_params[2],
614                                      &pub_params[3],
615                                      NULL);
616       for (idx=0; idx < 4 && !err; idx++)
617         if (gcry_mpi_cmp(pk->pkey[idx], pub_params[idx]))
618           err = gpg_error (GPG_ERR_BAD_PUBKEY);
619       if (!err)
620         {
621           gcry_mpi_release (pk->pkey[4]);
622           pk->pkey[4] = NULL;
623           err = gcry_sexp_extract_param (key, NULL, "x",
624                                          &pk->pkey[4],
625                                          NULL);
626         }
627       if (!err)
628         ski->csum += checksum_mpi (pk->pkey[4]);
629       break;
630
631     case GCRY_PK_ELG:
632       if (!is_ELGAMAL (pk->pubkey_algo))
633         goto bad_pubkey_algo;
634       err = gcry_sexp_extract_param (key, NULL, "pgy",
635                                      &pub_params[0],
636                                      &pub_params[1],
637                                      &pub_params[2],
638                                      NULL);
639       for (idx=0; idx < 3 && !err; idx++)
640         if (gcry_mpi_cmp(pk->pkey[idx], pub_params[idx]))
641           err = gpg_error (GPG_ERR_BAD_PUBKEY);
642       if (!err)
643         {
644           gcry_mpi_release (pk->pkey[3]);
645           pk->pkey[3] = NULL;
646           err = gcry_sexp_extract_param (key, NULL, "x",
647                                          &pk->pkey[3],
648                                          NULL);
649         }
650       if (!err)
651         ski->csum += checksum_mpi (pk->pkey[3]);
652       break;
653
654     case GCRY_PK_ECC:
655       err = match_curve_skey_pk (key, pk);
656       if (err)
657         goto leave;
658       if (!err)
659         err = gcry_sexp_extract_param (key, NULL, "q",
660                                        &pub_params[0],
661                                        NULL);
662       if (!err && (gcry_mpi_cmp(pk->pkey[1], pub_params[0])))
663         err = gpg_error (GPG_ERR_BAD_PUBKEY);
664
665       sec_start = 2;
666       if (pk->pubkey_algo == PUBKEY_ALGO_ECDH)
667         sec_start += 1;
668       if (!err)
669         {
670           gcry_mpi_release (pk->pkey[sec_start]);
671           pk->pkey[sec_start] = NULL;
672           err = gcry_sexp_extract_param (key, NULL, "d",
673                                          &pk->pkey[sec_start],
674                                          NULL);
675         }
676
677       if (!err)
678         ski->csum += checksum_mpi (pk->pkey[sec_start]);
679       break;
680
681     default:
682       pk->seckey_info = NULL;
683       xfree (ski);
684       err = gpg_error (GPG_ERR_NOT_IMPLEMENTED);
685       break;
686     }
687
688  leave:
689   gcry_sexp_release (top_list);
690   gcry_sexp_release (key);
691   gcry_free (key_type);
692
693   for (idx=0; idx < DIM(pub_params); idx++)
694     gcry_mpi_release (pub_params[idx]);
695   return err;
696
697  bad_pubkey_algo:
698   err = gpg_error (GPG_ERR_PUBKEY_ALGO);
699   goto leave;
700
701  bad_seckey:
702   err = gpg_error (GPG_ERR_BAD_SECKEY);
703   goto leave;
704 }
705
706
707 /* Use the key transfer format given in S_PGP to create the secinfo
708    structure in PK and change the parameter array in PK to include the
709    secret parameters.  */
710 static gpg_error_t
711 transfer_format_to_openpgp (gcry_sexp_t s_pgp, PKT_public_key *pk)
712 {
713   gpg_error_t err;
714   gcry_sexp_t top_list;
715   gcry_sexp_t list = NULL;
716   char *curve = NULL;
717   const char *value;
718   size_t valuelen;
719   char *string;
720   int  idx;
721   int  is_v4, is_protected;
722   enum gcry_pk_algos pk_algo;
723   int  protect_algo = 0;
724   char iv[16];
725   int  ivlen = 0;
726   int  s2k_mode = 0;
727   int  s2k_algo = 0;
728   byte s2k_salt[8];
729   u32  s2k_count = 0;
730   int  is_ecdh = 0;
731   size_t npkey, nskey;
732   gcry_mpi_t skey[10];  /* We support up to 9 parameters.  */
733   int skeyidx = 0;
734   struct seckey_info *ski;
735
736   /* gcry_log_debugsxp ("transferkey", s_pgp); */
737   top_list = gcry_sexp_find_token (s_pgp, "openpgp-private-key", 0);
738   if (!top_list)
739     goto bad_seckey;
740
741   list = gcry_sexp_find_token (top_list, "version", 0);
742   if (!list)
743     goto bad_seckey;
744   value = gcry_sexp_nth_data (list, 1, &valuelen);
745   if (!value || valuelen != 1 || !(value[0] == '3' || value[0] == '4'))
746     goto bad_seckey;
747   is_v4 = (value[0] == '4');
748
749   gcry_sexp_release (list);
750   list = gcry_sexp_find_token (top_list, "protection", 0);
751   if (!list)
752     goto bad_seckey;
753   value = gcry_sexp_nth_data (list, 1, &valuelen);
754   if (!value)
755     goto bad_seckey;
756   if (valuelen == 4 && !memcmp (value, "sha1", 4))
757     is_protected = 2;
758   else if (valuelen == 3 && !memcmp (value, "sum", 3))
759     is_protected = 1;
760   else if (valuelen == 4 && !memcmp (value, "none", 4))
761     is_protected = 0;
762   else
763     goto bad_seckey;
764   if (is_protected)
765     {
766       string = gcry_sexp_nth_string (list, 2);
767       if (!string)
768         goto bad_seckey;
769       protect_algo = gcry_cipher_map_name (string);
770       xfree (string);
771
772       value = gcry_sexp_nth_data (list, 3, &valuelen);
773       if (!value || !valuelen || valuelen > sizeof iv)
774         goto bad_seckey;
775       memcpy (iv, value, valuelen);
776       ivlen = valuelen;
777
778       string = gcry_sexp_nth_string (list, 4);
779       if (!string)
780         goto bad_seckey;
781       s2k_mode = strtol (string, NULL, 10);
782       xfree (string);
783
784       string = gcry_sexp_nth_string (list, 5);
785       if (!string)
786         goto bad_seckey;
787       s2k_algo = gcry_md_map_name (string);
788       xfree (string);
789
790       value = gcry_sexp_nth_data (list, 6, &valuelen);
791       if (!value || !valuelen || valuelen > sizeof s2k_salt)
792         goto bad_seckey;
793       memcpy (s2k_salt, value, valuelen);
794
795       string = gcry_sexp_nth_string (list, 7);
796       if (!string)
797         goto bad_seckey;
798       s2k_count = strtoul (string, NULL, 10);
799       xfree (string);
800     }
801
802   /* Parse the gcrypt PK algo and check that it is okay.  */
803   gcry_sexp_release (list);
804   list = gcry_sexp_find_token (top_list, "algo", 0);
805   if (!list)
806     goto bad_seckey;
807   string = gcry_sexp_nth_string (list, 1);
808   if (!string)
809     goto bad_seckey;
810   pk_algo = gcry_pk_map_name (string);
811   xfree (string); string = NULL;
812   if (gcry_pk_algo_info (pk_algo, GCRYCTL_GET_ALGO_NPKEY, NULL, &npkey)
813       || gcry_pk_algo_info (pk_algo, GCRYCTL_GET_ALGO_NSKEY, NULL, &nskey)
814       || !npkey || npkey >= nskey)
815     goto bad_seckey;
816
817   /* Check that the pubkey algo matches the one from the public key.  */
818   switch (canon_pk_algo (pk_algo))
819     {
820     case GCRY_PK_RSA:
821       if (!is_RSA (pk->pubkey_algo))
822         pk_algo = 0;  /* Does not match.  */
823       break;
824     case GCRY_PK_DSA:
825       if (!is_DSA (pk->pubkey_algo))
826         pk_algo = 0;  /* Does not match.  */
827       break;
828     case GCRY_PK_ELG:
829       if (!is_ELGAMAL (pk->pubkey_algo))
830         pk_algo = 0;  /* Does not match.  */
831       break;
832     case GCRY_PK_ECC:
833       if (pk->pubkey_algo == PUBKEY_ALGO_ECDSA)
834         ;
835       else if (pk->pubkey_algo == PUBKEY_ALGO_ECDH)
836         is_ecdh = 1;
837       else if (pk->pubkey_algo == PUBKEY_ALGO_EDDSA)
838         ;
839       else
840         pk_algo = 0;  /* Does not match.  */
841       /* For ECC we do not have the domain parameters thus fix our info.  */
842       npkey = 1;
843       nskey = 2;
844       break;
845     default:
846       pk_algo = 0;   /* Oops.  */
847       break;
848     }
849   if (!pk_algo)
850     {
851       err = gpg_error (GPG_ERR_PUBKEY_ALGO);
852       goto leave;
853     }
854
855   /* This check has to go after the ecc adjustments. */
856   if (nskey > PUBKEY_MAX_NSKEY)
857     goto bad_seckey;
858
859   /* Parse the key parameters.  */
860   gcry_sexp_release (list);
861   list = gcry_sexp_find_token (top_list, "skey", 0);
862   if (!list)
863     goto bad_seckey;
864   for (idx=0;;)
865     {
866       int is_enc;
867
868       value = gcry_sexp_nth_data (list, ++idx, &valuelen);
869       if (!value && skeyidx >= npkey)
870         break;  /* Ready.  */
871
872       /* Check for too many parameters.  Note that depending on the
873          protection mode and version number we may see less than NSKEY
874          (but at least NPKEY+1) parameters.  */
875       if (idx >= 2*nskey)
876         goto bad_seckey;
877       if (skeyidx >= DIM (skey)-1)
878         goto bad_seckey;
879
880       if (!value || valuelen != 1 || !(value[0] == '_' || value[0] == 'e'))
881         goto bad_seckey;
882       is_enc = (value[0] == 'e');
883       value = gcry_sexp_nth_data (list, ++idx, &valuelen);
884       if (!value || !valuelen)
885         goto bad_seckey;
886       if (is_enc)
887         {
888           void *p = xtrymalloc (valuelen);
889           if (!p)
890             goto outofmem;
891           memcpy (p, value, valuelen);
892           skey[skeyidx] = gcry_mpi_set_opaque (NULL, p, valuelen*8);
893           if (!skey[skeyidx])
894             goto outofmem;
895         }
896       else
897         {
898           if (gcry_mpi_scan (skey + skeyidx, GCRYMPI_FMT_STD,
899                              value, valuelen, NULL))
900             goto bad_seckey;
901         }
902       skeyidx++;
903     }
904   skey[skeyidx++] = NULL;
905
906   gcry_sexp_release (list); list = NULL;
907
908   /* We have no need for the CSUM value thus we don't parse it.  */
909   /* list = gcry_sexp_find_token (top_list, "csum", 0); */
910   /* if (list) */
911   /*   { */
912   /*     string = gcry_sexp_nth_string (list, 1); */
913   /*     if (!string) */
914   /*       goto bad_seckey; */
915   /*     desired_csum = strtoul (string, NULL, 10); */
916   /*     xfree (string); */
917   /*   } */
918   /* else */
919   /*   desired_csum = 0; */
920   /* gcry_sexp_release (list); list = NULL; */
921
922   /* Get the curve name if any,  */
923   list = gcry_sexp_find_token (top_list, "curve", 0);
924   if (list)
925     {
926       curve = gcry_sexp_nth_string (list, 1);
927       gcry_sexp_release (list); list = NULL;
928     }
929
930   gcry_sexp_release (top_list); top_list = NULL;
931
932   /* log_debug ("XXX is_v4=%d\n", is_v4); */
933   /* log_debug ("XXX pubkey_algo=%d\n", pubkey_algo); */
934   /* log_debug ("XXX is_protected=%d\n", is_protected); */
935   /* log_debug ("XXX protect_algo=%d\n", protect_algo); */
936   /* log_printhex ("XXX iv", iv, ivlen); */
937   /* log_debug ("XXX ivlen=%d\n", ivlen); */
938   /* log_debug ("XXX s2k_mode=%d\n", s2k_mode); */
939   /* log_debug ("XXX s2k_algo=%d\n", s2k_algo); */
940   /* log_printhex ("XXX s2k_salt", s2k_salt, sizeof s2k_salt); */
941   /* log_debug ("XXX s2k_count=%lu\n", (unsigned long)s2k_count); */
942   /* for (idx=0; skey[idx]; idx++) */
943   /*   { */
944   /*     int is_enc = gcry_mpi_get_flag (skey[idx], GCRYMPI_FLAG_OPAQUE); */
945   /*     log_info ("XXX skey[%d]%s:", idx, is_enc? " (enc)":""); */
946   /*     if (is_enc) */
947   /*       { */
948   /*         void *p; */
949   /*         unsigned int nbits; */
950   /*         p = gcry_mpi_get_opaque (skey[idx], &nbits); */
951   /*         log_printhex (NULL, p, (nbits+7)/8); */
952   /*       } */
953   /*     else */
954   /*       gcry_mpi_dump (skey[idx]); */
955   /*     log_printf ("\n"); */
956   /*   } */
957
958   if (!is_v4 || is_protected != 2 )
959     {
960       /* We only support the v4 format and a SHA-1 checksum.  */
961       err = gpg_error (GPG_ERR_NOT_IMPLEMENTED);
962       goto leave;
963     }
964
965   /* We need to change the received parameters for ECC algorithms.
966      The transfer format has the curve name and the parameters
967      separate.  We put them all into the SKEY array.  */
968   if (canon_pk_algo (pk_algo) == GCRY_PK_ECC)
969     {
970       const char *oidstr;
971
972       /* Assert that all required parameters are available.  We also
973          check that the array does not contain more parameters than
974          needed (this was used by some beta versions of 2.1.  */
975       if (!curve || !skey[0] || !skey[1] || skey[2])
976         {
977           err = gpg_error (GPG_ERR_INTERNAL);
978           goto leave;
979         }
980
981       oidstr = openpgp_curve_to_oid (curve, NULL);
982       if (!oidstr)
983         {
984           log_error ("no OID known for curve '%s'\n", curve);
985           err = gpg_error (GPG_ERR_UNKNOWN_CURVE);
986           goto leave;
987         }
988       /* Put the curve's OID into into the MPI array.  This requires
989          that we shift Q and D.  For ECDH also insert the KDF parms. */
990       if (is_ecdh)
991         {
992           skey[4] = NULL;
993           skey[3] = skey[1];
994           skey[2] = gcry_mpi_copy (pk->pkey[2]);
995         }
996       else
997         {
998           skey[3] = NULL;
999           skey[2] = skey[1];
1000         }
1001       skey[1] = skey[0];
1002       skey[0] = NULL;
1003       err = openpgp_oid_from_str (oidstr, skey + 0);
1004       if (err)
1005         goto leave;
1006       /* Fixup the NPKEY and NSKEY to match OpenPGP reality.  */
1007       npkey = 2 + is_ecdh;
1008       nskey = 3 + is_ecdh;
1009
1010       /* for (idx=0; skey[idx]; idx++) */
1011       /*   { */
1012       /*     log_info ("YYY skey[%d]:", idx); */
1013       /*     if (gcry_mpi_get_flag (skey[idx], GCRYMPI_FLAG_OPAQUE)) */
1014       /*       { */
1015       /*         void *p; */
1016       /*         unsigned int nbits; */
1017       /*         p = gcry_mpi_get_opaque (skey[idx], &nbits); */
1018       /*         log_printhex (NULL, p, (nbits+7)/8); */
1019       /*       } */
1020       /*     else */
1021       /*       gcry_mpi_dump (skey[idx]); */
1022       /*     log_printf ("\n"); */
1023       /*   } */
1024     }
1025
1026   /* Do some sanity checks.  */
1027   if (s2k_count > 255)
1028     {
1029       /* We expect an already encoded S2K count.  */
1030       err = gpg_error (GPG_ERR_INV_DATA);
1031       goto leave;
1032     }
1033   err = openpgp_cipher_test_algo (protect_algo);
1034   if (err)
1035     goto leave;
1036   err = openpgp_md_test_algo (s2k_algo);
1037   if (err)
1038     goto leave;
1039
1040   /* Check that the public key parameters match.  Note that since
1041      Libgcrypt 1.5 gcry_mpi_cmp handles opaque MPI correctly.  */
1042   for (idx=0; idx < npkey; idx++)
1043     if (gcry_mpi_cmp (pk->pkey[idx], skey[idx]))
1044       {
1045         err = gpg_error (GPG_ERR_BAD_PUBKEY);
1046         goto leave;
1047       }
1048
1049   /* Check that the first secret key parameter in SKEY is encrypted
1050      and that there are no more secret key parameters.  The latter is
1051      guaranteed by the v4 packet format.  */
1052   if (!gcry_mpi_get_flag (skey[npkey], GCRYMPI_FLAG_OPAQUE))
1053     goto bad_seckey;
1054   if (npkey+1 < DIM (skey) && skey[npkey+1])
1055     goto bad_seckey;
1056
1057   /* Check that the secret key parameters in PK are all set to NULL. */
1058   for (idx=npkey; idx < nskey; idx++)
1059     if (pk->pkey[idx])
1060       goto bad_seckey;
1061
1062   /* Now build the protection info. */
1063   pk->seckey_info = ski = xtrycalloc (1, sizeof *ski);
1064   if (!ski)
1065     {
1066       err = gpg_error_from_syserror ();
1067       goto leave;
1068     }
1069
1070   ski->is_protected = 1;
1071   ski->sha1chk = 1;
1072   ski->algo = protect_algo;
1073   ski->s2k.mode = s2k_mode;
1074   ski->s2k.hash_algo = s2k_algo;
1075   log_assert (sizeof ski->s2k.salt == sizeof s2k_salt);
1076   memcpy (ski->s2k.salt, s2k_salt, sizeof s2k_salt);
1077   ski->s2k.count = s2k_count;
1078   log_assert (ivlen <= sizeof ski->iv);
1079   memcpy (ski->iv, iv, ivlen);
1080   ski->ivlen = ivlen;
1081
1082   /* Store the protected secret key parameter.  */
1083   pk->pkey[npkey] = skey[npkey];
1084   skey[npkey] = NULL;
1085
1086   /* That's it.  */
1087
1088  leave:
1089   gcry_free (curve);
1090   gcry_sexp_release (list);
1091   gcry_sexp_release (top_list);
1092   for (idx=0; idx < skeyidx; idx++)
1093     gcry_mpi_release (skey[idx]);
1094   return err;
1095
1096  bad_seckey:
1097   err = gpg_error (GPG_ERR_BAD_SECKEY);
1098   goto leave;
1099
1100  outofmem:
1101   err = gpg_error (GPG_ERR_ENOMEM);
1102   goto leave;
1103 }
1104
1105
1106 /* Print an "EXPORTED" status line.  PK is the primary public key.  */
1107 static void
1108 print_status_exported (PKT_public_key *pk)
1109 {
1110   char *hexfpr;
1111
1112   if (!is_status_enabled ())
1113     return;
1114
1115   hexfpr = hexfingerprint (pk, NULL, 0);
1116   write_status_text (STATUS_EXPORTED, hexfpr? hexfpr : "[?]");
1117   xfree (hexfpr);
1118 }
1119
1120
1121 /*
1122  * Receive a secret key from agent specified by HEXGRIP.
1123  *
1124  * Since the key data from agant is encrypted, decrypt it by CIPHERHD.
1125  * Then, parse the decrypted key data in transfer format, and put
1126  * secret parameters into PK.
1127  *
1128  * If CLEARTEXT is 0, store the secret key material
1129  * passphrase-protected.  Otherwise, store secret key material in the
1130  * clear.
1131  *
1132  * CACHE_NONCE_ADDR is used to share nonce for multple key retrievals.
1133  */
1134 gpg_error_t
1135 receive_seckey_from_agent (ctrl_t ctrl, gcry_cipher_hd_t cipherhd,
1136                            int cleartext,
1137                            char **cache_nonce_addr, const char *hexgrip,
1138                            PKT_public_key *pk)
1139 {
1140   gpg_error_t err = 0;
1141   unsigned char *wrappedkey = NULL;
1142   size_t wrappedkeylen;
1143   unsigned char *key = NULL;
1144   size_t keylen, realkeylen;
1145   gcry_sexp_t s_skey;
1146   char *prompt;
1147
1148   if (opt.verbose)
1149     log_info ("key %s: asking agent for the secret parts\n", hexgrip);
1150
1151   prompt = gpg_format_keydesc (pk, FORMAT_KEYDESC_EXPORT,1);
1152   err = agent_export_key (ctrl, hexgrip, prompt, !cleartext, cache_nonce_addr,
1153                           &wrappedkey, &wrappedkeylen);
1154   xfree (prompt);
1155
1156   if (err)
1157     goto unwraperror;
1158   if (wrappedkeylen < 24)
1159     {
1160       err = gpg_error (GPG_ERR_INV_LENGTH);
1161       goto unwraperror;
1162     }
1163   keylen = wrappedkeylen - 8;
1164   key = xtrymalloc_secure (keylen);
1165   if (!key)
1166     {
1167       err = gpg_error_from_syserror ();
1168       goto unwraperror;
1169     }
1170   err = gcry_cipher_decrypt (cipherhd, key, keylen, wrappedkey, wrappedkeylen);
1171   if (err)
1172     goto unwraperror;
1173   realkeylen = gcry_sexp_canon_len (key, keylen, NULL, &err);
1174   if (!realkeylen)
1175     goto unwraperror; /* Invalid csexp.  */
1176
1177   err = gcry_sexp_sscan (&s_skey, NULL, key, realkeylen);
1178   if (!err)
1179     {
1180       if (cleartext)
1181         err = cleartext_secret_key_to_openpgp (s_skey, pk);
1182       else
1183         err = transfer_format_to_openpgp (s_skey, pk);
1184       gcry_sexp_release (s_skey);
1185     }
1186
1187  unwraperror:
1188   xfree (key);
1189   xfree (wrappedkey);
1190   if (err)
1191     {
1192       log_error ("key %s: error receiving key from agent:"
1193                  " %s%s\n", hexgrip, gpg_strerror (err),
1194                  gpg_err_code (err) == GPG_ERR_FULLY_CANCELED?
1195                  "":_(" - skipped"));
1196     }
1197   return err;
1198 }
1199
1200
1201 /* Helper for apply_keep_uid_filter.  */
1202 static const char *
1203 filter_getval (void *cookie, const char *propname)
1204 {
1205   kbnode_t node = cookie;
1206   const char *result;
1207
1208   if (node->pkt->pkttype == PKT_USER_ID)
1209     {
1210       if (!strcmp (propname, "uid"))
1211         result = node->pkt->pkt.user_id->name;
1212       else if (!strcmp (propname, "mbox"))
1213         {
1214           if (!node->pkt->pkt.user_id->mbox)
1215             {
1216               node->pkt->pkt.user_id->mbox
1217                 = mailbox_from_userid (node->pkt->pkt.user_id->name);
1218             }
1219           return node->pkt->pkt.user_id->mbox;
1220         }
1221       else if (!strcmp (propname, "primary"))
1222         result = node->pkt->pkt.user_id->is_primary? "1":"0";
1223       else
1224         result = NULL;
1225     }
1226   else
1227     result = NULL;
1228
1229   return result;
1230 }
1231
1232 /*
1233  * Apply the keep-uid filter to the keyblock.  The deleted nodes are
1234  * marked and thus the caller should call commit_kbnode afterwards.
1235  * KEYBLOCK must not have any blocks marked as deleted.
1236  */
1237 static void
1238 apply_keep_uid_filter (kbnode_t keyblock, recsel_expr_t selector)
1239 {
1240   kbnode_t node;
1241
1242   for (node = keyblock->next; node; node = node->next )
1243     {
1244       if (node->pkt->pkttype == PKT_USER_ID)
1245         {
1246           if (!recsel_select (selector, filter_getval, node))
1247             {
1248
1249               log_debug ("keep-uid: deleting '%s'\n",
1250                          node->pkt->pkt.user_id->name);
1251               /* The UID packet and all following packets up to the
1252                * next UID or a subkey.  */
1253               delete_kbnode (node);
1254               for (; node->next
1255                      && node->next->pkt->pkttype != PKT_USER_ID
1256                      && node->next->pkt->pkttype != PKT_PUBLIC_SUBKEY
1257                      && node->next->pkt->pkttype != PKT_SECRET_SUBKEY ;
1258                    node = node->next)
1259                 delete_kbnode (node->next);
1260             }
1261           else
1262             log_debug ("keep-uid: keeping '%s'\n",
1263                        node->pkt->pkt.user_id->name);
1264         }
1265     }
1266 }
1267
1268
1269 /* Helper for do_export_stream which writes one keyblock to OUT.  */
1270 static gpg_error_t
1271 do_export_one_keyblock (ctrl_t ctrl, kbnode_t keyblock, u32 *keyid,
1272                         iobuf_t out, int secret, unsigned int options,
1273                         export_stats_t stats, int *any,
1274                         KEYDB_SEARCH_DESC *desc, size_t ndesc,
1275                         size_t descindex, gcry_cipher_hd_t cipherhd)
1276 {
1277   gpg_error_t err;
1278   char *cache_nonce = NULL;
1279   subkey_list_t subkey_list = NULL;  /* Track already processed subkeys. */
1280   int skip_until_subkey = 0;
1281   int cleartext = 0;
1282   char *hexgrip = NULL;
1283   char *serialno = NULL;
1284   PKT_public_key *pk;
1285   u32 subkidbuf[2], *subkid;
1286   kbnode_t kbctx, node;
1287
1288   for (kbctx=NULL; (node = walk_kbnode (keyblock, &kbctx, 0)); )
1289     {
1290       if (skip_until_subkey)
1291         {
1292           if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
1293             skip_until_subkey = 0;
1294           else
1295             continue;
1296         }
1297
1298       /* We used to use comment packets, but not any longer.  In
1299        * case we still have comments on a key, strip them here
1300        * before we call build_packet(). */
1301       if (node->pkt->pkttype == PKT_COMMENT)
1302         continue;
1303
1304       /* Make sure that ring_trust packets never get exported. */
1305       if (node->pkt->pkttype == PKT_RING_TRUST)
1306         continue;
1307
1308       /* If exact is set, then we only export what was requested
1309        * (plus the primary key, if the user didn't specifically
1310        * request it). */
1311       if (desc[descindex].exact && node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
1312         {
1313           if (!exact_subkey_match_p (desc+descindex, node))
1314             {
1315               /* Before skipping this subkey, check whether any
1316                * other description wants an exact match on a
1317                * subkey and include that subkey into the output
1318                * too.  Need to add this subkey to a list so that
1319                * it won't get processed a second time.
1320                *
1321                * So the first step here is to check that list and
1322                * skip in any case if the key is in that list.
1323                *
1324                * We need this whole mess because the import
1325                * function of GnuPG < 2.1 is not able to merge
1326                * secret keys and thus it is useless to output them
1327                * as two separate keys and have import merge them.
1328                */
1329               if (subkey_in_list_p (subkey_list, node))
1330                 skip_until_subkey = 1; /* Already processed this one. */
1331               else
1332                 {
1333                   size_t j;
1334
1335                   for (j=0; j < ndesc; j++)
1336                     if (j != descindex && desc[j].exact
1337                         && exact_subkey_match_p (desc+j, node))
1338                       break;
1339                   if (!(j < ndesc))
1340                     skip_until_subkey = 1; /* No other one matching. */
1341                 }
1342             }
1343
1344           if (skip_until_subkey)
1345             continue;
1346
1347           /* Mark this one as processed. */
1348           {
1349             subkey_list_t tmp = new_subkey_list_item (node);
1350             tmp->next = subkey_list;
1351             subkey_list = tmp;
1352           }
1353         }
1354
1355       if (node->pkt->pkttype == PKT_SIGNATURE)
1356         {
1357           /* Do not export packets which are marked as not
1358            * exportable.  */
1359           if (!(options & EXPORT_LOCAL_SIGS)
1360               && !node->pkt->pkt.signature->flags.exportable)
1361             continue; /* not exportable */
1362
1363           /* Do not export packets with a "sensitive" revocation key
1364            * unless the user wants us to.  Note that we do export
1365            * these when issuing the actual revocation (see revoke.c). */
1366           if (!(options & EXPORT_SENSITIVE_REVKEYS)
1367               && node->pkt->pkt.signature->revkey)
1368             {
1369               int i;
1370
1371               for (i = 0; i < node->pkt->pkt.signature->numrevkeys; i++)
1372                 if ((node->pkt->pkt.signature->revkey[i].class & 0x40))
1373                   break;
1374               if (i < node->pkt->pkt.signature->numrevkeys)
1375                 continue;
1376             }
1377         }
1378
1379       /* Don't export attribs? */
1380       if (!(options & EXPORT_ATTRIBUTES)
1381           && node->pkt->pkttype == PKT_USER_ID
1382           && node->pkt->pkt.user_id->attrib_data)
1383         {
1384           /* Skip until we get to something that is not an attrib or a
1385            * signature on an attrib.  */
1386           while (kbctx->next && kbctx->next->pkt->pkttype == PKT_SIGNATURE)
1387             kbctx = kbctx->next;
1388
1389           continue;
1390         }
1391
1392       if (secret && (node->pkt->pkttype == PKT_PUBLIC_KEY
1393                      || node->pkt->pkttype == PKT_PUBLIC_SUBKEY))
1394         {
1395           pk = node->pkt->pkt.public_key;
1396           if (node->pkt->pkttype == PKT_PUBLIC_KEY)
1397             subkid = NULL;
1398           else
1399             {
1400               keyid_from_pk (pk, subkidbuf);
1401               subkid = subkidbuf;
1402             }
1403
1404           if (pk->seckey_info)
1405             {
1406               log_error ("key %s: oops: seckey_info already set"
1407                          " - skipped\n", keystr_with_sub (keyid, subkid));
1408               skip_until_subkey = 1;
1409               continue;
1410             }
1411
1412           xfree (hexgrip);
1413           err = hexkeygrip_from_pk (pk, &hexgrip);
1414           if (err)
1415             {
1416               log_error ("key %s: error computing keygrip: %s"
1417                          " - skipped\n", keystr_with_sub (keyid, subkid),
1418                          gpg_strerror (err));
1419               skip_until_subkey = 1;
1420               err = 0;
1421               continue;
1422             }
1423
1424           xfree (serialno);
1425           serialno = NULL;
1426           if (secret == 2 && node->pkt->pkttype == PKT_PUBLIC_KEY)
1427             {
1428               /* We are asked not to export the secret parts of the
1429                * primary key.  Make up an error code to create the
1430                * stub.  */
1431               err = GPG_ERR_NOT_FOUND;
1432             }
1433           else
1434             err = agent_get_keyinfo (ctrl, hexgrip, &serialno, &cleartext);
1435
1436           if ((!err && serialno)
1437               && secret == 2 && node->pkt->pkttype == PKT_PUBLIC_KEY)
1438             {
1439               /* It does not make sense to export a key with its
1440                * primary key on card using a non-key stub.  Thus we
1441                * skip those keys when used with --export-secret-subkeys. */
1442               log_info (_("key %s: key material on-card - skipped\n"),
1443                         keystr_with_sub (keyid, subkid));
1444               skip_until_subkey = 1;
1445             }
1446           else if (gpg_err_code (err) == GPG_ERR_NOT_FOUND
1447                    || (!err && serialno))
1448             {
1449               /* Create a key stub.  */
1450               struct seckey_info *ski;
1451               const char *s;
1452
1453               pk->seckey_info = ski = xtrycalloc (1, sizeof *ski);
1454               if (!ski)
1455                 {
1456                   err = gpg_error_from_syserror ();
1457                   goto leave;
1458                 }
1459
1460               ski->is_protected = 1;
1461               if (err)
1462                 ski->s2k.mode = 1001; /* GNU dummy (no secret key).  */
1463               else
1464                 {
1465                   ski->s2k.mode = 1002; /* GNU-divert-to-card.  */
1466                   for (s=serialno; sizeof (ski->ivlen) && *s && s[1];
1467                        ski->ivlen++, s += 2)
1468                     ski->iv[ski->ivlen] = xtoi_2 (s);
1469                 }
1470
1471               err = build_packet (out, node->pkt);
1472               if (!err && node->pkt->pkttype == PKT_PUBLIC_KEY)
1473                 {
1474                   stats->exported++;
1475                   print_status_exported (node->pkt->pkt.public_key);
1476                 }
1477             }
1478           else if (!err)
1479             {
1480               err = receive_seckey_from_agent (ctrl, cipherhd,
1481                                                cleartext, &cache_nonce,
1482                                                hexgrip, pk);
1483               if (err)
1484                 {
1485                   if (gpg_err_code (err) == GPG_ERR_FULLY_CANCELED)
1486                     goto leave;
1487                   skip_until_subkey = 1;
1488                   err = 0;
1489                 }
1490               else
1491                 {
1492                   err = build_packet (out, node->pkt);
1493                   if (node->pkt->pkttype == PKT_PUBLIC_KEY)
1494                     {
1495                       stats->exported++;
1496                       print_status_exported (node->pkt->pkt.public_key);
1497                     }
1498                 }
1499             }
1500           else
1501             {
1502               log_error ("key %s: error getting keyinfo from agent: %s"
1503                          " - skipped\n", keystr_with_sub (keyid, subkid),
1504                              gpg_strerror (err));
1505               skip_until_subkey = 1;
1506               err = 0;
1507             }
1508
1509           xfree (pk->seckey_info);
1510           pk->seckey_info = NULL;
1511           {
1512             int i;
1513             for (i = pubkey_get_npkey (pk->pubkey_algo);
1514                  i < pubkey_get_nskey (pk->pubkey_algo); i++)
1515               {
1516                 gcry_mpi_release (pk->pkey[i]);
1517                 pk->pkey[i] = NULL;
1518               }
1519           }
1520         }
1521       else /* Not secret or common packets.  */
1522         {
1523           err = build_packet (out, node->pkt);
1524           if (!err && node->pkt->pkttype == PKT_PUBLIC_KEY)
1525             {
1526               stats->exported++;
1527               print_status_exported (node->pkt->pkt.public_key);
1528             }
1529         }
1530
1531       if (err)
1532         {
1533           log_error ("build_packet(%d) failed: %s\n",
1534                      node->pkt->pkttype, gpg_strerror (err));
1535           goto leave;
1536         }
1537
1538       if (!skip_until_subkey)
1539         *any = 1;
1540     }
1541
1542  leave:
1543   release_subkey_list (subkey_list);
1544   xfree (serialno);
1545   xfree (hexgrip);
1546   xfree (cache_nonce);
1547   return err;
1548 }
1549
1550
1551 /* Export the keys identified by the list of strings in USERS to the
1552    stream OUT.  If SECRET is false public keys will be exported.  With
1553    secret true secret keys will be exported; in this case 1 means the
1554    entire secret keyblock and 2 only the subkeys.  OPTIONS are the
1555    export options to apply.  If KEYBLOCK_OUT is not NULL, AND the exit
1556    code is zero, a pointer to the first keyblock found and exported
1557    will be stored at this address; no other keyblocks are exported in
1558    this case.  The caller must free the returned keyblock.  If any
1559    key has been exported true is stored at ANY. */
1560 static int
1561 do_export_stream (ctrl_t ctrl, iobuf_t out, strlist_t users, int secret,
1562                   kbnode_t *keyblock_out, unsigned int options,
1563                   export_stats_t stats, int *any)
1564 {
1565   gpg_error_t err = 0;
1566   PACKET pkt;
1567   kbnode_t keyblock = NULL;
1568   kbnode_t node;
1569   size_t ndesc, descindex;
1570   KEYDB_SEARCH_DESC *desc = NULL;
1571   KEYDB_HANDLE kdbhd;
1572   strlist_t sl;
1573   gcry_cipher_hd_t cipherhd = NULL;
1574   struct export_stats_s dummystats;
1575
1576   if (!stats)
1577     stats = &dummystats;
1578   *any = 0;
1579   init_packet (&pkt);
1580   kdbhd = keydb_new ();
1581   if (!kdbhd)
1582     return gpg_error_from_syserror ();
1583
1584   /* For the DANE format override the options.  */
1585   if ((options & EXPORT_DANE_FORMAT))
1586     options = (EXPORT_DANE_FORMAT | EXPORT_MINIMAL | EXPORT_CLEAN);
1587
1588
1589   if (!users)
1590     {
1591       ndesc = 1;
1592       desc = xcalloc (ndesc, sizeof *desc);
1593       desc[0].mode = KEYDB_SEARCH_MODE_FIRST;
1594     }
1595   else
1596     {
1597       for (ndesc=0, sl=users; sl; sl = sl->next, ndesc++)
1598         ;
1599       desc = xmalloc ( ndesc * sizeof *desc);
1600
1601       for (ndesc=0, sl=users; sl; sl = sl->next)
1602         {
1603           if (!(err=classify_user_id (sl->d, desc+ndesc, 1)))
1604             ndesc++;
1605           else
1606             log_error (_("key \"%s\" not found: %s\n"),
1607                        sl->d, gpg_strerror (err));
1608         }
1609
1610       keydb_disable_caching (kdbhd);  /* We are looping the search.  */
1611
1612       /* It would be nice to see which of the given users did actually
1613          match one in the keyring.  To implement this we need to have
1614          a found flag for each entry in desc.  To set this flag we
1615          must check all those entries after a match to mark all
1616          matched one - currently we stop at the first match.  To do
1617          this we need an extra flag to enable this feature.  */
1618     }
1619
1620 #ifdef ENABLE_SELINUX_HACKS
1621   if (secret)
1622     {
1623       log_error (_("exporting secret keys not allowed\n"));
1624       err = gpg_error (GPG_ERR_NOT_SUPPORTED);
1625       goto leave;
1626     }
1627 #endif
1628
1629   /* For secret key export we need to setup a decryption context.  */
1630   if (secret)
1631     {
1632       void *kek = NULL;
1633       size_t keklen;
1634
1635       err = agent_keywrap_key (ctrl, 1, &kek, &keklen);
1636       if (err)
1637         {
1638           log_error ("error getting the KEK: %s\n", gpg_strerror (err));
1639           goto leave;
1640         }
1641
1642       /* Prepare a cipher context.  */
1643       err = gcry_cipher_open (&cipherhd, GCRY_CIPHER_AES128,
1644                               GCRY_CIPHER_MODE_AESWRAP, 0);
1645       if (!err)
1646         err = gcry_cipher_setkey (cipherhd, kek, keklen);
1647       if (err)
1648         {
1649           log_error ("error setting up an encryption context: %s\n",
1650                      gpg_strerror (err));
1651           goto leave;
1652         }
1653       xfree (kek);
1654       kek = NULL;
1655     }
1656
1657   for (;;)
1658     {
1659       u32 keyid[2];
1660       PKT_public_key *pk;
1661
1662       err = keydb_search (kdbhd, desc, ndesc, &descindex);
1663       if (!users)
1664         desc[0].mode = KEYDB_SEARCH_MODE_NEXT;
1665       if (err)
1666         break;
1667
1668       /* Read the keyblock. */
1669       release_kbnode (keyblock);
1670       keyblock = NULL;
1671       err = keydb_get_keyblock (kdbhd, &keyblock);
1672       if (err)
1673         {
1674           log_error (_("error reading keyblock: %s\n"), gpg_strerror (err));
1675           goto leave;
1676         }
1677
1678       node = find_kbnode (keyblock, PKT_PUBLIC_KEY);
1679       if (!node)
1680         {
1681           log_error ("public key packet not found in keyblock - skipped\n");
1682           continue;
1683         }
1684       stats->count++;
1685       setup_main_keyids (keyblock);  /* gpg_format_keydesc needs it.  */
1686       pk = node->pkt->pkt.public_key;
1687       keyid_from_pk (pk, keyid);
1688
1689       /* If a secret key export is required we need to check whether
1690          we have a secret key at all and if so create the seckey_info
1691          structure.  */
1692       if (secret)
1693         {
1694           if (agent_probe_any_secret_key (ctrl, keyblock))
1695             continue;  /* No secret key (neither primary nor subkey).  */
1696
1697           /* No v3 keys with GNU mode 1001. */
1698           if (secret == 2 && pk->version == 3)
1699             {
1700               log_info (_("key %s: PGP 2.x style key - skipped\n"),
1701                         keystr (keyid));
1702               continue;
1703             }
1704
1705           /* The agent does not yet allow to export v3 packets.  It is
1706              actually questionable whether we should allow them at
1707              all.  */
1708           if (pk->version == 3)
1709             {
1710               log_info ("key %s: PGP 2.x style key (v3) export "
1711                         "not yet supported - skipped\n", keystr (keyid));
1712               continue;
1713             }
1714           stats->secret_count++;
1715         }
1716
1717       /* Always do the cleaning on the public key part if requested.
1718          Note that we don't yet set this option if we are exporting
1719          secret keys.  Note that both export-clean and export-minimal
1720          only apply to UID sigs (0x10, 0x11, 0x12, and 0x13).  A
1721          designated revocation is never stripped, even with
1722          export-minimal set.  */
1723       if ((options & EXPORT_CLEAN))
1724         clean_key (keyblock, opt.verbose, (options&EXPORT_MINIMAL), NULL, NULL);
1725
1726       if (export_keep_uid)
1727         {
1728           commit_kbnode (&keyblock);
1729           apply_keep_uid_filter (keyblock, export_keep_uid);
1730           commit_kbnode (&keyblock);
1731         }
1732
1733       /* And write it. */
1734       err = do_export_one_keyblock (ctrl, keyblock, keyid, out, secret,
1735                                     options, stats, any,
1736                                     desc, ndesc, descindex, cipherhd);
1737       if (err)
1738         break;
1739
1740       if (keyblock_out)
1741         {
1742           *keyblock_out = keyblock;
1743           break;
1744         }
1745     }
1746   if (gpg_err_code (err) == GPG_ERR_NOT_FOUND)
1747     err = 0;
1748
1749  leave:
1750   gcry_cipher_close (cipherhd);
1751   xfree(desc);
1752   keydb_release (kdbhd);
1753   if (err || !keyblock_out)
1754     release_kbnode( keyblock );
1755   if( !*any )
1756     log_info(_("WARNING: nothing exported\n"));
1757   return err;
1758 }
1759
1760
1761
1762 \f
1763 static gpg_error_t
1764 key_to_sshblob (membuf_t *mb, const char *identifier, ...)
1765 {
1766   va_list arg_ptr;
1767   gpg_error_t err = 0;
1768   unsigned char nbuf[4];
1769   unsigned char *buf;
1770   size_t buflen;
1771   gcry_mpi_t a;
1772
1773   ulongtobuf (nbuf, (ulong)strlen (identifier));
1774   put_membuf (mb, nbuf, 4);
1775   put_membuf_str (mb, identifier);
1776   if (!strncmp (identifier, "ecdsa-sha2-", 11))
1777     {
1778       ulongtobuf (nbuf, (ulong)strlen (identifier+11));
1779       put_membuf (mb, nbuf, 4);
1780       put_membuf_str (mb, identifier+11);
1781     }
1782   va_start (arg_ptr, identifier);
1783   while ((a = va_arg (arg_ptr, gcry_mpi_t)))
1784     {
1785       err = gcry_mpi_aprint (GCRYMPI_FMT_SSH, &buf, &buflen, a);
1786       if (err)
1787         break;
1788       if (!strcmp (identifier, "ssh-ed25519")
1789           && buflen > 5 && buf[4] == 0x40)
1790         {
1791           /* We need to strip our 0x40 prefix.  */
1792           put_membuf (mb, "\x00\x00\x00\x20", 4);
1793           put_membuf (mb, buf+5, buflen-5);
1794         }
1795       else
1796         put_membuf (mb, buf, buflen);
1797       gcry_free (buf);
1798     }
1799   va_end (arg_ptr);
1800   return err;
1801 }
1802
1803 /* Export the key identified by USERID in the SSH public key format.
1804    The function exports the latest subkey with Authentication
1805    capability unless the '!' suffix is used to export a specific
1806    key.  */
1807 gpg_error_t
1808 export_ssh_key (ctrl_t ctrl, const char *userid)
1809 {
1810   gpg_error_t err;
1811   kbnode_t keyblock = NULL;
1812   KEYDB_SEARCH_DESC desc;
1813   u32 latest_date;
1814   u32 curtime = make_timestamp ();
1815   kbnode_t latest_key, node;
1816   PKT_public_key *pk;
1817   const char *identifier;
1818   membuf_t mb;
1819   estream_t fp = NULL;
1820   struct b64state b64_state;
1821   const char *fname = "-";
1822
1823   init_membuf (&mb, 4096);
1824
1825   /* We need to know whether the key has been specified using the
1826      exact syntax ('!' suffix).  Thus we need to run a
1827      classify_user_id on our own.  */
1828   err = classify_user_id (userid, &desc, 1);
1829
1830   /* Get the public key.  */
1831   if (!err)
1832     {
1833       getkey_ctx_t getkeyctx;
1834
1835       err = get_pubkey_byname (ctrl, &getkeyctx, NULL, userid, &keyblock,
1836                                NULL,
1837                                0  /* Only usable keys or given exact. */,
1838                                1  /* No AKL lookup.  */);
1839       if (!err)
1840         {
1841           err = getkey_next (getkeyctx, NULL, NULL);
1842           if (!err)
1843             err = gpg_error (GPG_ERR_AMBIGUOUS_NAME);
1844           else if (gpg_err_code (err) == GPG_ERR_NO_PUBKEY)
1845             err = 0;
1846         }
1847       getkey_end (getkeyctx);
1848     }
1849   if (err)
1850     {
1851       log_error (_("key \"%s\" not found: %s\n"), userid, gpg_strerror (err));
1852       return err;
1853     }
1854
1855   /* The finish_lookup code in getkey.c does not handle auth keys,
1856      thus we have to duplicate the code here to find the latest
1857      subkey.  However, if the key has been found using an exact match
1858      ('!' notation) we use that key without any further checks and
1859      even allow the use of the primary key. */
1860   latest_date = 0;
1861   latest_key = NULL;
1862   for (node = keyblock; node; node = node->next)
1863     {
1864       if ((node->pkt->pkttype == PKT_PUBLIC_SUBKEY
1865            || node->pkt->pkttype == PKT_PUBLIC_KEY)
1866           && node->pkt->pkt.public_key->flags.exact)
1867         {
1868           latest_key = node;
1869           break;
1870         }
1871     }
1872   if (!latest_key)
1873     {
1874       for (node = keyblock; node; node = node->next)
1875         {
1876           if (node->pkt->pkttype != PKT_PUBLIC_SUBKEY)
1877             continue;
1878
1879           pk = node->pkt->pkt.public_key;
1880           if (DBG_LOOKUP)
1881             log_debug ("\tchecking subkey %08lX\n",
1882                        (ulong) keyid_from_pk (pk, NULL));
1883           if (!(pk->pubkey_usage & PUBKEY_USAGE_AUTH))
1884             {
1885               if (DBG_LOOKUP)
1886                 log_debug ("\tsubkey not usable for authentication\n");
1887               continue;
1888             }
1889           if (!pk->flags.valid)
1890             {
1891               if (DBG_LOOKUP)
1892                 log_debug ("\tsubkey not valid\n");
1893               continue;
1894             }
1895           if (pk->flags.revoked)
1896             {
1897               if (DBG_LOOKUP)
1898                 log_debug ("\tsubkey has been revoked\n");
1899               continue;
1900             }
1901           if (pk->has_expired)
1902             {
1903               if (DBG_LOOKUP)
1904                 log_debug ("\tsubkey has expired\n");
1905               continue;
1906             }
1907           if (pk->timestamp > curtime && !opt.ignore_valid_from)
1908             {
1909               if (DBG_LOOKUP)
1910                 log_debug ("\tsubkey not yet valid\n");
1911               continue;
1912             }
1913           if (DBG_LOOKUP)
1914             log_debug ("\tsubkey might be fine\n");
1915           /* In case a key has a timestamp of 0 set, we make sure that it
1916              is used.  A better change would be to compare ">=" but that
1917              might also change the selected keys and is as such a more
1918              intrusive change.  */
1919           if (pk->timestamp > latest_date || (!pk->timestamp && !latest_date))
1920             {
1921               latest_date = pk->timestamp;
1922               latest_key = node;
1923             }
1924         }
1925     }
1926
1927   if (!latest_key)
1928     {
1929       err = gpg_error (GPG_ERR_UNUSABLE_PUBKEY);
1930       log_error (_("key \"%s\" not found: %s\n"), userid, gpg_strerror (err));
1931       goto leave;
1932     }
1933
1934   pk = latest_key->pkt->pkt.public_key;
1935   if (DBG_LOOKUP)
1936     log_debug ("\tusing key %08lX\n", (ulong) keyid_from_pk (pk, NULL));
1937
1938   switch (pk->pubkey_algo)
1939     {
1940     case PUBKEY_ALGO_DSA:
1941       identifier = "ssh-dss";
1942       err = key_to_sshblob (&mb, identifier,
1943                             pk->pkey[0], pk->pkey[1], pk->pkey[2], pk->pkey[3],
1944                             NULL);
1945       break;
1946
1947     case PUBKEY_ALGO_RSA:
1948     case PUBKEY_ALGO_RSA_S:
1949       identifier = "ssh-rsa";
1950       err = key_to_sshblob (&mb, identifier, pk->pkey[1], pk->pkey[0], NULL);
1951       break;
1952
1953     case PUBKEY_ALGO_ECDSA:
1954       {
1955         char *curveoid;
1956         const char *curve;
1957
1958         curveoid = openpgp_oid_to_str (pk->pkey[0]);
1959         if (!curveoid)
1960           err = gpg_error_from_syserror ();
1961         else if (!(curve = openpgp_oid_to_curve (curveoid, 0)))
1962           err = gpg_error (GPG_ERR_UNKNOWN_CURVE);
1963         else
1964           {
1965             if (!strcmp (curve, "nistp256"))
1966               identifier = "ecdsa-sha2-nistp256";
1967             else if (!strcmp (curve, "nistp384"))
1968               identifier = "ecdsa-sha2-nistp384";
1969             else if (!strcmp (curve, "nistp521"))
1970               identifier = "ecdsa-sha2-nistp521";
1971             else
1972               identifier = NULL;
1973
1974             if (!identifier)
1975               err = gpg_error (GPG_ERR_UNKNOWN_CURVE);
1976             else
1977               err = key_to_sshblob (&mb, identifier, pk->pkey[1], NULL);
1978           }
1979         xfree (curveoid);
1980       }
1981       break;
1982
1983     case PUBKEY_ALGO_EDDSA:
1984       if (!openpgp_oid_is_ed25519 (pk->pkey[0]))
1985         err = gpg_error (GPG_ERR_UNKNOWN_CURVE);
1986       else
1987         {
1988           identifier = "ssh-ed25519";
1989           err = key_to_sshblob (&mb, identifier, pk->pkey[1], NULL);
1990         }
1991       break;
1992
1993     case PUBKEY_ALGO_ELGAMAL_E:
1994     case PUBKEY_ALGO_ELGAMAL:
1995       err = gpg_error (GPG_ERR_UNUSABLE_PUBKEY);
1996       break;
1997
1998     default:
1999       err = GPG_ERR_PUBKEY_ALGO;
2000       break;
2001     }
2002
2003   if (err)
2004     goto leave;
2005
2006   if (opt.outfile && *opt.outfile && strcmp (opt.outfile, "-"))
2007     fp = es_fopen ((fname = opt.outfile), "w");
2008   else
2009     fp = es_stdout;
2010   if (!fp)
2011     {
2012       err = gpg_error_from_syserror ();
2013       log_error (_("error creating '%s': %s\n"), fname, gpg_strerror (err));
2014       goto leave;
2015     }
2016
2017   es_fprintf (fp, "%s ", identifier);
2018   err = b64enc_start_es (&b64_state, fp, "");
2019   if (err)
2020     goto leave;
2021   {
2022     void *blob;
2023     size_t bloblen;
2024
2025     blob = get_membuf (&mb, &bloblen);
2026     if (!blob)
2027       err = gpg_error_from_syserror ();
2028     else
2029       err = b64enc_write (&b64_state, blob, bloblen);
2030     xfree (blob);
2031     if (err)
2032       goto leave;
2033   }
2034   err = b64enc_finish (&b64_state);
2035   if (err)
2036     goto leave;
2037   es_fprintf (fp, " openpgp:0x%08lX\n", (ulong)keyid_from_pk (pk, NULL));
2038
2039   if (es_ferror (fp))
2040     err = gpg_error_from_syserror ();
2041   else
2042     {
2043       if (es_fclose (fp))
2044         err = gpg_error_from_syserror ();
2045       fp = NULL;
2046     }
2047
2048   if (err)
2049     log_error (_("error writing '%s': %s\n"), fname, gpg_strerror (err));
2050
2051  leave:
2052   es_fclose (fp);
2053   xfree (get_membuf (&mb, NULL));
2054   release_kbnode (keyblock);
2055   return err;
2056 }