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