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