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