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