2 * Copyright 2021 The OpenSSL Project Authors. All Rights Reserved.
4 * Licensed under the Apache License 2.0 (the "License"). You may not use
5 * this file except in compliance with the License. You can obtain a copy
6 * in the file LICENSE in the source distribution or at
7 * https://www.openssl.org/source/license.html
11 * Some ctrls depend on deprecated functionality. We trust that this is
12 * functionality that remains internally even when 'no-deprecated' is
13 * configured. When we drop #legacy EVP_PKEYs, this source should be
14 * possible to drop as well.
16 #include "internal/deprecated.h"
20 /* The following includes get us all the EVP_PKEY_CTRL macros */
21 #include <openssl/dh.h>
22 #include <openssl/dsa.h>
23 #include <openssl/ec.h>
24 #include <openssl/rsa.h>
25 #include <openssl/kdf.h>
27 /* This include gets us all the OSSL_PARAM key string macros */
28 #include <openssl/core_names.h>
30 #include <openssl/err.h>
31 #include <openssl/evperr.h>
32 #include <openssl/params.h>
33 #include "internal/nelem.h"
34 #include "internal/cryptlib.h"
35 #include "internal/ffc.h"
36 #include "crypto/evp.h"
37 #include "crypto/dh.h"
38 #include "crypto/ec.h"
40 #include "e_os.h" /* strcasecmp() for Windows */
42 struct translation_ctx_st; /* Forwarding */
43 struct translation_st; /* Forwarding */
46 * The fixup_args functions are called with the following parameters:
48 * |state| The state we're called in, explained further at the
49 * end of this comment.
50 * |translation| The translation item, to be pilfered for data as
52 * |ctx| The translation context, which contains copies of
53 * the following arguments, applicable according to
54 * the caller. All of the attributes in this context
55 * may be freely modified by the fixup_args function.
56 * For cleanup, call cleanup_translation_ctx().
58 * The |state| tells the fixup_args function something about the caller and
59 * what they may expect:
61 * PKEY The fixup_args function has been called
62 * from an EVP_PKEY payload getter / setter,
63 * and is fully responsible for getting or
64 * setting the requested data. With this
65 * state, the fixup_args function is expected
66 * to use or modify |*params|, depending on
69 * PRE_CTRL_TO_PARAMS The fixup_args function has been called
70 * POST_CTRL_TO_PARAMS from EVP_PKEY_CTX_ctrl(), to help with
71 * translating the ctrl data to an OSSL_PARAM
72 * element or back. The calling sequence is
75 * 1. fixup_args(PRE_CTRL_TO_PARAMS, ...)
76 * 2. EVP_PKEY_CTX_set_params() or
77 * EVP_PKEY_CTX_get_params()
78 * 3. fixup_args(POST_CTRL_TO_PARAMS, ...)
80 * With the PRE_CTRL_TO_PARAMS state, the
81 * fixup_args function is expected to modify
82 * the passed |*params| in whatever way
83 * necessary, when |action_type == SET|.
84 * With the POST_CTRL_TO_PARAMS state, the
85 * fixup_args function is expected to modify
86 * the passed |p2| in whatever way necessary,
87 * when |action_type == GET|.
89 * The return value from the fixup_args call
90 * with the POST_CTRL_TO_PARAMS state becomes
91 * the return value back to EVP_PKEY_CTX_ctrl().
93 * CLEANUP_CTRL_TO_PARAMS The cleanup_args functions has been called
94 * from EVP_PKEY_CTX_ctrl(), to clean up what
95 * the fixup_args function has done, if needed.
98 * PRE_CTRL_STR_TO_PARAMS The fixup_args function has been called
99 * POST_CTRL_STR_TO_PARAMS from EVP_PKEY_CTX_ctrl_str(), to help with
100 * translating the ctrl_str data to an
101 * OSSL_PARAM element or back. The calling
102 * sequence is as follows:
104 * 1. fixup_args(PRE_CTRL_STR_TO_PARAMS, ...)
105 * 2. EVP_PKEY_CTX_set_params() or
106 * EVP_PKEY_CTX_get_params()
107 * 3. fixup_args(POST_CTRL_STR_TO_PARAMS, ...)
109 * With the PRE_CTRL_STR_TO_PARAMS state,
110 * the fixup_args function is expected to
111 * modify the passed |*params| in whatever
112 * way necessary, when |action_type == SET|.
113 * With the POST_CTRL_STR_TO_PARAMS state,
114 * the fixup_args function is only expected
117 * CLEANUP_CTRL_STR_TO_PARAMS The cleanup_args functions has been called
118 * from EVP_PKEY_CTX_ctrl_str(), to clean up
119 * what the fixup_args function has done, if
122 * PRE_PARAMS_TO_CTRL The fixup_args function has been called
123 * POST_PARAMS_TO_CTRL from EVP_PKEY_CTX_get_params() or
124 * EVP_PKEY_CTX_set_params(), to help with
125 * translating the OSSL_PARAM data to the
126 * corresponding EVP_PKEY_CTX_ctrl() arguments
127 * or the other way around. The calling
128 * sequence is as follows:
130 * 1. fixup_args(PRE_PARAMS_TO_CTRL, ...)
131 * 2. EVP_PKEY_CTX_ctrl()
132 * 3. fixup_args(POST_PARAMS_TO_CTRL, ...)
134 * With the PRE_PARAMS_TO_CTRL state, the
135 * fixup_args function is expected to modify
136 * the passed |p1| and |p2| in whatever way
137 * necessary, when |action_type == SET|.
138 * With the POST_PARAMS_TO_CTRL state, the
139 * fixup_args function is expected to
140 * modify the passed |*params| in whatever
141 * way necessary, when |action_type == GET|.
143 * CLEANUP_PARAMS_TO_CTRL The cleanup_args functions has been called
144 * from EVP_PKEY_CTX_get_params() or
145 * EVP_PKEY_CTX_set_params(), to clean up what
146 * the fixup_args function has done, if needed.
150 PRE_CTRL_TO_PARAMS, POST_CTRL_TO_PARAMS, CLEANUP_CTRL_TO_PARAMS,
151 PRE_CTRL_STR_TO_PARAMS, POST_CTRL_STR_TO_PARAMS, CLEANUP_CTRL_STR_TO_PARAMS,
152 PRE_PARAMS_TO_CTRL, POST_PARAMS_TO_CTRL, CLEANUP_PARAMS_TO_CTRL
155 NONE = 0, GET = 1, SET = 2
157 typedef int fixup_args_fn(enum state state,
158 const struct translation_st *translation,
159 struct translation_ctx_st *ctx);
160 typedef int cleanup_args_fn(enum state state,
161 const struct translation_st *translation,
162 struct translation_ctx_st *ctx);
164 struct translation_ctx_st {
166 * The EVP_PKEY_CTX, for calls on that structure, to be pilfered for data
171 * The action type (GET or SET). This may be 0 in some cases, and should
172 * be modified by the fixup_args function in the PRE states. It should
173 * otherwise remain untouched once set.
175 enum action action_type;
177 * For ctrl to params translation, the actual ctrl command number used.
178 * For params to ctrl translation, 0.
182 * For ctrl_str to params translation, the actual ctrl command string
183 * used. In this case, the (string) value is always passed as |p2|.
184 * For params to ctrl translation, this is NULL. Along with it is also
185 * and indicator whether it matched |ctrl_str| or |ctrl_hexstr| in the
188 const char *ctrl_str;
190 /* the ctrl-style int argument. */
192 /* the ctrl-style void* argument. */
194 /* a size, for passing back the |p2| size where applicable */
196 /* pointer to the OSSL_PARAM-style params array. */
200 * The following are used entirely internally by the fixup_args functions
201 * and should not be touched by the callers, at all.
205 * Copy of the ctrl-style void* argument, if the fixup_args function
206 * needs to manipulate |p2| but wants to remember original.
209 /* Diverse types of storage for the needy. */
210 char name_buf[OSSL_MAX_NAME_SIZE];
216 struct translation_st {
218 * What this table item does.
220 * If the item has this set to 0, it means that both GET and SET are
221 * supported, and |fixup_args| will determine which it is. This is to
222 * support translations of ctrls where the action type depends on the
223 * value of |p1| or |p2| (ctrls are really bi-directional, but are
224 * seldom used that way).
226 * This can be also used in the lookup template when it looks up by
227 * OSSL_PARAM key, to indicate if a setter or a getter called.
229 enum action action_type;
232 * Conditions, for params->ctrl translations.
234 * In table item, |keytype1| and |keytype2| can be set to -1 to indicate
235 * that this item supports all key types (or rather, that |fixup_args|
236 * will check and return an error if it's not supported).
237 * Any of these may be set to 0 to indicate that they are unset.
239 int keytype1; /* The EVP_PKEY_XXX type, i.e. NIDs. #legacy */
240 int keytype2; /* Another EVP_PKEY_XXX type, used for aliases */
241 int optype; /* The operation type */
244 * Lookup and translation attributes
246 * |ctrl_num|, |ctrl_str|, |ctrl_hexstr| and |param_key| are lookup
249 * |ctrl_num| may be 0 or that |param_key| may be NULL in the table item,
250 * but not at the same time. If they are, they are simply not used for
252 * When |ctrl_num| == 0, no ctrl will be called. Likewise, when
253 * |param_key| == NULL, no OSSL_PARAM setter/getter will be called.
254 * In that case the treatment of the translation item relies entirely on
255 * |fixup_args|, which is then assumed to have side effects.
257 * As a special case, it's possible to set |ctrl_hexstr| and assign NULL
258 * to |ctrl_str|. That will signal to default_fixup_args() that the
259 * value must always be interpreted as hex.
261 int ctrl_num; /* EVP_PKEY_CTRL_xxx */
262 const char *ctrl_str; /* The corresponding ctrl string */
263 const char *ctrl_hexstr; /* The alternative "hex{str}" ctrl string */
264 const char *param_key; /* The corresponding OSSL_PARAM key */
266 * The appropriate OSSL_PARAM data type. This may be 0 to indicate that
267 * this OSSL_PARAM may have more than one data type, depending on input
268 * material. In this case, |fixup_args| is expected to check and handle
271 unsigned int param_data_type;
276 * |fixup_args| is always called before (for SET) or after (for GET)
277 * the actual ctrl / OSSL_PARAM function.
279 fixup_args_fn *fixup_args;
283 * Fixer function implementations
284 * ==============================
288 * default_check isn't a fixer per se, but rather a helper function to
289 * perform certain standard checks.
291 static int default_check(enum state state,
292 const struct translation_st *translation,
293 const struct translation_ctx_st *ctx)
298 case PRE_CTRL_TO_PARAMS:
299 if (!ossl_assert(translation != NULL)) {
300 ERR_raise(ERR_LIB_EVP, EVP_R_COMMAND_NOT_SUPPORTED);
303 if (!ossl_assert(translation->param_key != 0)
304 || !ossl_assert(translation->param_data_type != 0)) {
305 ERR_raise(ERR_LIB_EVP, ERR_R_INTERNAL_ERROR);
309 case PRE_CTRL_STR_TO_PARAMS:
311 * For ctrl_str to params translation, we allow direct use of
312 * OSSL_PARAM keys as ctrl_str keys. Therefore, it's possible that
313 * we end up with |translation == NULL|, which is fine. The fixup
314 * function will have to deal with it carefully.
316 if (translation != NULL) {
317 if (!ossl_assert(translation->action_type != GET)) {
318 ERR_raise(ERR_LIB_EVP, EVP_R_COMMAND_NOT_SUPPORTED);
321 if (!ossl_assert(translation->param_key != NULL)
322 || !ossl_assert(translation->param_data_type != 0)) {
323 ERR_raise(ERR_LIB_EVP, ERR_R_INTERNAL_ERROR);
328 case PRE_PARAMS_TO_CTRL:
329 case POST_PARAMS_TO_CTRL:
330 if (!ossl_assert(translation != NULL)) {
331 ERR_raise(ERR_LIB_EVP, EVP_R_COMMAND_NOT_SUPPORTED);
334 if (!ossl_assert(translation->ctrl_num != 0)
335 || !ossl_assert(translation->param_data_type != 0)) {
336 ERR_raise(ERR_LIB_EVP, ERR_R_INTERNAL_ERROR);
341 /* Nothing else to check */
346 * default_fixup_args fixes up all sorts of arguments, governed by the
347 * diverse attributes in the translation item. It covers all "standard"
348 * base ctrl functionality, meaning it can handle basic conversion of
349 * data between p1+p2 (SET) or return value+p2 (GET) as long as the values
350 * don't have extra semantics (such as NIDs, OIDs, that sort of stuff).
351 * Extra semantics must be handled via specific fixup_args functions.
353 * The following states and action type combinations have standard handling
354 * done in this function:
356 * PRE_CTRL_TO_PARAMS, 0 - ERROR. action type must be
357 * determined by a fixup function.
358 * PRE_CTRL_TO_PARAMS, SET | GET - |p1| and |p2| are converted to an
359 * OSSL_PARAM according to the data
360 * type given in |translattion|.
361 * For OSSL_PARAM_UNSIGNED_INTEGER,
362 * a BIGNUM passed as |p2| is accepted.
363 * POST_CTRL_TO_PARAMS, GET - If the OSSL_PARAM data type is a
364 * STRING or PTR type, |p1| is set
365 * to the OSSL_PARAM return size, and
366 * |p2| is set to the string.
367 * PRE_CTRL_STR_TO_PARAMS, !SET - ERROR. That combination is not
369 * PRE_CTRL_STR_TO_PARAMS, SET - |p2| is taken as a string, and is
370 * converted to an OSSL_PARAM in a
371 * standard manner, guided by the
372 * param key and data type from
374 * PRE_PARAMS_TO_CTRL, SET - the OSSL_PARAM is converted to
375 * |p1| and |p2| according to the
376 * data type given in |translation|
377 * For OSSL_PARAM_UNSIGNED_INTEGER,
378 * if |p2| is non-NULL, then |*p2|
379 * is assigned a BIGNUM, otherwise
380 * |p1| is assigned an unsigned int.
381 * POST_PARAMS_TO_CTRL, GET - |p1| and |p2| are converted to
382 * an OSSL_PARAM, in the same manner
383 * as for the combination of
384 * PRE_CTRL_TO_PARAMS, SET.
386 static int default_fixup_args(enum state state,
387 const struct translation_st *translation,
388 struct translation_ctx_st *ctx)
392 if ((ret = default_check(state, translation, ctx)) < 0)
397 /* For states this function should never have been called with */
398 ERR_raise_data(ERR_LIB_EVP, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED,
399 "[action:%d, state:%d]", ctx->action_type, state);
403 * PRE_CTRL_TO_PARAMS and POST_CTRL_TO_PARAMS handle ctrl to params
404 * translations. PRE_CTRL_TO_PARAMS is responsible for preparing
405 * |*params|, and POST_CTRL_TO_PARAMS is responsible for bringing the
406 * result back to |*p2| and the return value.
408 case PRE_CTRL_TO_PARAMS:
409 /* This is ctrl to params translation, so we need an OSSL_PARAM key */
410 if (ctx->action_type == NONE) {
412 * No action type is an error here. That's a case for a
413 * special fixup function.
415 ERR_raise_data(ERR_LIB_EVP, ERR_R_UNSUPPORTED,
416 "[action:%d, state:%d]", ctx->action_type, state);
420 if (translation->optype != 0) {
421 if ((EVP_PKEY_CTX_IS_SIGNATURE_OP(ctx->pctx)
422 && ctx->pctx->op.sig.algctx == NULL)
423 || (EVP_PKEY_CTX_IS_DERIVE_OP(ctx->pctx)
424 && ctx->pctx->op.kex.algctx == NULL)
425 || (EVP_PKEY_CTX_IS_ASYM_CIPHER_OP(ctx->pctx)
426 && ctx->pctx->op.ciph.algctx == NULL)
427 || (EVP_PKEY_CTX_IS_KEM_OP(ctx->pctx)
428 && ctx->pctx->op.encap.algctx == NULL)
430 * The following may be unnecessary, but we have them
431 * for good measure...
433 || (EVP_PKEY_CTX_IS_GEN_OP(ctx->pctx)
434 && ctx->pctx->op.keymgmt.genctx == NULL)
435 || (EVP_PKEY_CTX_IS_FROMDATA_OP(ctx->pctx)
436 && ctx->pctx->op.keymgmt.genctx == NULL)) {
437 ERR_raise(ERR_LIB_EVP, EVP_R_COMMAND_NOT_SUPPORTED);
438 /* Uses the same return values as EVP_PKEY_CTX_ctrl */
444 * OSSL_PARAM_construct_TYPE() works equally well for both SET and GET.
446 switch (translation->param_data_type) {
447 case OSSL_PARAM_INTEGER:
448 *ctx->params = OSSL_PARAM_construct_int(translation->param_key,
451 case OSSL_PARAM_UNSIGNED_INTEGER:
453 * BIGNUMs are passed via |p2|. For all ctrl's that just want
454 * to pass a simple integer via |p1|, |p2| is expected to be
457 * Note that this allocates a buffer, which the cleanup function
460 if (ctx->p2 != NULL) {
461 if (ctx->action_type == SET) {
462 ctx->buflen = BN_num_bytes(ctx->p2);
463 if ((ctx->allocated_buf =
464 OPENSSL_malloc(ctx->buflen)) == NULL) {
465 ERR_raise(ERR_LIB_EVP, ERR_R_MALLOC_FAILURE);
468 if (!BN_bn2nativepad(ctx->p2,
469 ctx->allocated_buf, ctx->buflen)) {
470 OPENSSL_free(ctx->allocated_buf);
471 ctx->allocated_buf = NULL;
475 OSSL_PARAM_construct_BN(translation->param_key,
480 * No support for getting a BIGNUM by ctrl, this needs
481 * fixup_args function support.
483 ERR_raise_data(ERR_LIB_EVP, ERR_R_UNSUPPORTED,
484 "[action:%d, state:%d] trying to get a "
485 "BIGNUM via ctrl call",
486 ctx->action_type, state);
491 OSSL_PARAM_construct_uint(translation->param_key,
492 (unsigned int *)&ctx->p1);
495 case OSSL_PARAM_UTF8_STRING:
497 OSSL_PARAM_construct_utf8_string(translation->param_key,
498 ctx->p2, (size_t)ctx->p1);
500 case OSSL_PARAM_UTF8_PTR:
502 OSSL_PARAM_construct_utf8_ptr(translation->param_key,
503 ctx->p2, (size_t)ctx->p1);
505 case OSSL_PARAM_OCTET_STRING:
507 OSSL_PARAM_construct_octet_string(translation->param_key,
508 ctx->p2, (size_t)ctx->p1);
510 case OSSL_PARAM_OCTET_PTR:
512 OSSL_PARAM_construct_octet_ptr(translation->param_key,
513 ctx->p2, (size_t)ctx->p1);
517 case POST_CTRL_TO_PARAMS:
519 * Because EVP_PKEY_CTX_ctrl() returns the length of certain objects
520 * as its return value, we need to ensure that we do it here as well,
521 * for the OSSL_PARAM data types where this makes sense.
523 if (ctx->action_type == GET) {
524 switch (translation->param_data_type) {
525 case OSSL_PARAM_UTF8_STRING:
526 case OSSL_PARAM_UTF8_PTR:
527 case OSSL_PARAM_OCTET_STRING:
528 case OSSL_PARAM_OCTET_PTR:
529 ctx->p1 = (int)ctx->params[0].return_size;
536 * PRE_CTRL_STR_TO_PARAMS and POST_CTRL_STR_TO_PARAMS handle ctrl_str to
537 * params translations. PRE_CTRL_TO_PARAMS is responsible for preparing
538 * |*params|, and POST_CTRL_TO_PARAMS currently has nothing to do, since
539 * there's no support for getting data via ctrl_str calls.
541 case PRE_CTRL_STR_TO_PARAMS:
543 /* This is ctrl_str to params translation */
544 const char *tmp_ctrl_str = ctx->ctrl_str;
545 const char *orig_ctrl_str = ctx->ctrl_str;
546 const char *orig_value = ctx->p2;
547 const OSSL_PARAM *settable = NULL;
550 /* Only setting is supported here */
551 if (ctx->action_type != SET) {
552 ERR_raise_data(ERR_LIB_EVP, EVP_R_COMMAND_NOT_SUPPORTED,
553 "[action:%d, state:%d] only setting allowed",
554 ctx->action_type, state);
559 * If no translation exists, we simply pass the control string
562 if (translation != NULL) {
563 tmp_ctrl_str = ctx->ctrl_str = translation->param_key;
566 strcpy(ctx->name_buf, "hex");
567 if (OPENSSL_strlcat(ctx->name_buf, tmp_ctrl_str,
568 sizeof(ctx->name_buf)) <= 3) {
569 ERR_raise(ERR_LIB_EVP, ERR_R_INTERNAL_ERROR);
572 tmp_ctrl_str = ctx->name_buf;
576 settable = EVP_PKEY_CTX_settable_params(ctx->pctx);
577 if (!OSSL_PARAM_allocate_from_text(ctx->params, settable,
579 ctx->p2, strlen(ctx->p2),
582 ERR_raise_data(ERR_LIB_EVP, EVP_R_COMMAND_NOT_SUPPORTED,
583 "[action:%d, state:%d] name=%s, value=%s",
584 ctx->action_type, state,
585 orig_ctrl_str, orig_value);
590 ctx->allocated_buf = ctx->params->data;
591 ctx->buflen = ctx->params->data_size;
594 case POST_CTRL_STR_TO_PARAMS:
595 /* Nothing to be done */
599 * PRE_PARAMS_TO_CTRL and POST_PARAMS_TO_CTRL handle params to ctrl
600 * translations. PRE_PARAMS_TO_CTRL is responsible for preparing
601 * |p1| and |p2|, and POST_PARAMS_TO_CTRL is responsible for bringing
602 * the EVP_PKEY_CTX_ctrl() return value (passed as |p1|) and |p2| back
605 * PKEY is treated just like POST_PARAMS_TO_CTRL, making it easy
606 * for the related fixup_args functions to just set |p1| and |p2|
607 * appropriately and leave it to this section of code to fix up
608 * |ctx->params| accordingly.
611 case POST_PARAMS_TO_CTRL:
614 case PRE_PARAMS_TO_CTRL:
616 /* This is params to ctrl translation */
617 if (state == PRE_PARAMS_TO_CTRL && ctx->action_type == SET) {
618 /* For the PRE state, only setting needs some work to be done */
620 /* When setting, we populate |p1| and |p2| from |*params| */
621 switch (translation->param_data_type) {
622 case OSSL_PARAM_INTEGER:
623 return OSSL_PARAM_get_int(ctx->params, &ctx->p1);
624 case OSSL_PARAM_UNSIGNED_INTEGER:
625 if (ctx->p2 != NULL) {
626 /* BIGNUM passed down with p2 */
627 if (!OSSL_PARAM_get_BN(ctx->params, ctx->p2))
630 /* Normal C unsigned int passed down */
631 if (!OSSL_PARAM_get_uint(ctx->params,
632 (unsigned int *)&ctx->p1))
636 case OSSL_PARAM_UTF8_STRING:
637 return OSSL_PARAM_get_utf8_string(ctx->params,
639 case OSSL_PARAM_OCTET_STRING:
640 return OSSL_PARAM_get_octet_string(ctx->params,
643 case OSSL_PARAM_OCTET_PTR:
644 return OSSL_PARAM_get_octet_ptr(ctx->params,
647 ERR_raise_data(ERR_LIB_EVP, ERR_R_UNSUPPORTED,
648 "[action:%d, state:%d] "
649 "unknown OSSL_PARAM data type %d",
650 ctx->action_type, state,
651 translation->param_data_type);
654 } else if ((state == POST_PARAMS_TO_CTRL || state == PKEY)
655 && ctx->action_type == GET) {
656 /* For the POST state, only getting needs some work to be done */
658 /* When getting, we populate |*params| from |p1| and |p2| */
659 switch (translation->param_data_type) {
660 case OSSL_PARAM_INTEGER:
661 return OSSL_PARAM_set_int(ctx->params, ctx->p1);
662 case OSSL_PARAM_UNSIGNED_INTEGER:
663 if (ctx->p2 != NULL) {
664 /* BIGNUM passed back */
665 return OSSL_PARAM_set_BN(ctx->params, ctx->p2);
667 /* Normal C unsigned int passed back */
668 return OSSL_PARAM_set_uint(ctx->params,
669 (unsigned int)ctx->p1);
672 case OSSL_PARAM_UTF8_STRING:
673 return OSSL_PARAM_set_utf8_string(ctx->params, ctx->p2);
674 case OSSL_PARAM_OCTET_STRING:
675 return OSSL_PARAM_set_octet_string(ctx->params, ctx->p2,
677 case OSSL_PARAM_OCTET_PTR:
678 return OSSL_PARAM_set_octet_ptr(ctx->params, ctx->p2,
681 ERR_raise_data(ERR_LIB_EVP, ERR_R_UNSUPPORTED,
682 "[action:%d, state:%d] "
683 "unsupported OSSL_PARAM data type %d",
684 ctx->action_type, state,
685 translation->param_data_type);
690 /* Any other combination is simply pass-through */
697 cleanup_translation_ctx(enum state state,
698 const struct translation_st *translation,
699 struct translation_ctx_st *ctx)
701 if (ctx->allocated_buf != NULL)
702 OPENSSL_free(ctx->allocated_buf);
703 ctx->allocated_buf = NULL;
708 * fix_cipher_md fixes up an EVP_CIPHER / EVP_MD to its name on SET,
709 * and cipher / md name to EVP_MD on GET.
711 static const char *get_cipher_name(void *cipher)
713 return EVP_CIPHER_get0_name(cipher);
716 static const char *get_md_name(void *md)
718 return EVP_MD_get0_name(md);
721 static const void *get_cipher_by_name(OSSL_LIB_CTX *libctx, const char *name)
723 return evp_get_cipherbyname_ex(libctx, name);
726 static const void *get_md_by_name(OSSL_LIB_CTX *libctx, const char *name)
728 return evp_get_digestbyname_ex(libctx, name);
731 static int fix_cipher_md(enum state state,
732 const struct translation_st *translation,
733 struct translation_ctx_st *ctx,
734 const char *(*get_name)(void *algo),
735 const void *(*get_algo_by_name)(OSSL_LIB_CTX *libctx,
740 if ((ret = default_check(state, translation, ctx)) <= 0)
743 if (state == PRE_CTRL_TO_PARAMS && ctx->action_type == GET) {
745 * |ctx->p2| contains the address to an EVP_CIPHER or EVP_MD pointer
746 * to be filled in. We need to remember it, then make |ctx->p2|
747 * point at a buffer to be filled in with the name, and |ctx->p1|
748 * with its size. default_fixup_args() will take care of the rest
751 ctx->orig_p2 = ctx->p2;
752 ctx->p2 = ctx->name_buf;
753 ctx->p1 = sizeof(ctx->name_buf);
754 } else if (state == PRE_CTRL_TO_PARAMS && ctx->action_type == SET) {
756 * In different parts of OpenSSL, this ctrl command is used
757 * differently. Some calls pass a NID as p1, others pass an
758 * EVP_CIPHER pointer as p2...
760 ctx->p2 = (char *)(ctx->p2 == NULL
761 ? OBJ_nid2sn(ctx->p1)
762 : get_name(ctx->p2));
763 ctx->p1 = strlen(ctx->p2);
764 } else if (state == POST_PARAMS_TO_CTRL && ctx->action_type == GET) {
765 ctx->p2 = (ctx->p2 == NULL ? "" : (char *)get_name(ctx->p2));
766 ctx->p1 = strlen(ctx->p2);
769 if ((ret = default_fixup_args(state, translation, ctx)) <= 0)
772 if (state == POST_CTRL_TO_PARAMS && ctx->action_type == GET) {
774 * Here's how we re-use |ctx->orig_p2| that was set in the
775 * PRE_CTRL_TO_PARAMS state above.
777 *(void **)ctx->orig_p2 =
778 (void *)get_algo_by_name(ctx->pctx->libctx, ctx->p2);
780 } else if (state == PRE_PARAMS_TO_CTRL && ctx->action_type == SET) {
781 ctx->p2 = (void *)get_algo_by_name(ctx->pctx->libctx, ctx->p2);
788 static int fix_cipher(enum state state,
789 const struct translation_st *translation,
790 struct translation_ctx_st *ctx)
792 return fix_cipher_md(state, translation, ctx,
793 get_cipher_name, get_cipher_by_name);
796 static int fix_md(enum state state,
797 const struct translation_st *translation,
798 struct translation_ctx_st *ctx)
800 return fix_cipher_md(state, translation, ctx,
801 get_md_name, get_md_by_name);
804 static int fix_distid_len(enum state state,
805 const struct translation_st *translation,
806 struct translation_ctx_st *ctx)
808 int ret = default_fixup_args(state, translation, ctx);
812 if ((state == POST_CTRL_TO_PARAMS
813 || state == POST_CTRL_STR_TO_PARAMS) && ctx->action_type == GET) {
814 *(size_t *)ctx->p2 = ctx->sz;
821 struct kdf_type_map_st {
823 const char *kdf_type_str;
826 static int fix_kdf_type(enum state state,
827 const struct translation_st *translation,
828 struct translation_ctx_st *ctx,
829 const struct kdf_type_map_st *kdf_type_map)
832 * The EVP_PKEY_CTRL_DH_KDF_TYPE ctrl command is a bit special, in
833 * that it's used both for setting a value, and for getting it, all
834 * depending on the value if |p1|; if |p1| is -2, the backend is
835 * supposed to place the current kdf type in |p2|, and if not, |p1|
836 * is interpreted as the new kdf type.
840 if ((ret = default_check(state, translation, ctx)) <= 0)
843 if (state == PRE_CTRL_TO_PARAMS) {
845 * In |translations|, the initial value for |ctx->action_type| must
848 if (!ossl_assert(ctx->action_type == NONE))
851 /* The action type depends on the value of *p1 */
854 * The OSSL_PARAMS getter needs space to store a copy of the kdf
855 * type string. We use |ctx->name_buf|, which has enough space
858 * (this wouldn't be needed if the OSSL_xxx_PARAM_KDF_TYPE
859 * had the data type OSSL_PARAM_UTF8_PTR)
861 ctx->p2 = ctx->name_buf;
862 ctx->p1 = sizeof(ctx->name_buf);
863 ctx->action_type = GET;
865 ctx->action_type = SET;
869 if ((ret = default_check(state, translation, ctx)) <= 0)
872 if ((state == PRE_CTRL_TO_PARAMS && ctx->action_type == SET)
873 || (state == POST_PARAMS_TO_CTRL && ctx->action_type == GET)) {
875 /* Convert KDF type numbers to strings */
876 for (; kdf_type_map->kdf_type_str != NULL; kdf_type_map++)
877 if (ctx->p1 == kdf_type_map->kdf_type_num) {
878 ctx->p2 = (char *)kdf_type_map->kdf_type_str;
884 ctx->p1 = strlen(ctx->p2);
887 if ((ret = default_fixup_args(state, translation, ctx)) <= 0)
890 if ((state == POST_CTRL_TO_PARAMS && ctx->action_type == GET)
891 || (state == PRE_PARAMS_TO_CTRL && ctx->action_type == SET)) {
894 /* Convert KDF type strings to numbers */
895 for (; kdf_type_map->kdf_type_str != NULL; kdf_type_map++)
896 if (strcasecmp(ctx->p2, kdf_type_map->kdf_type_str) == 0) {
897 ctx->p1 = kdf_type_map->kdf_type_num;
902 } else if (state == PRE_PARAMS_TO_CTRL && ctx->action_type == GET) {
909 /* EVP_PKEY_CTRL_DH_KDF_TYPE */
910 static int fix_dh_kdf_type(enum state state,
911 const struct translation_st *translation,
912 struct translation_ctx_st *ctx)
914 static const struct kdf_type_map_st kdf_type_map[] = {
915 { EVP_PKEY_DH_KDF_NONE, "" },
916 { EVP_PKEY_DH_KDF_X9_42, OSSL_KDF_NAME_X942KDF_ASN1 },
920 return fix_kdf_type(state, translation, ctx, kdf_type_map);
923 /* EVP_PKEY_CTRL_EC_KDF_TYPE */
924 static int fix_ec_kdf_type(enum state state,
925 const struct translation_st *translation,
926 struct translation_ctx_st *ctx)
928 static const struct kdf_type_map_st kdf_type_map[] = {
929 { EVP_PKEY_ECDH_KDF_NONE, "" },
930 { EVP_PKEY_ECDH_KDF_X9_63, OSSL_KDF_NAME_X963KDF },
934 return fix_kdf_type(state, translation, ctx, kdf_type_map);
937 /* EVP_PKEY_CTRL_DH_KDF_OID, EVP_PKEY_CTRL_GET_DH_KDF_OID, ...??? */
938 static int fix_oid(enum state state,
939 const struct translation_st *translation,
940 struct translation_ctx_st *ctx)
944 if ((ret = default_check(state, translation, ctx)) <= 0)
947 if ((state == PRE_CTRL_TO_PARAMS && ctx->action_type == SET)
948 || (state == POST_PARAMS_TO_CTRL && ctx->action_type == GET)) {
950 * We're translating from ctrl to params and setting the OID, or
951 * we're translating from params to ctrl and getting the OID.
952 * Either way, |ctx->p2| points at an ASN1_OBJECT, and needs to have
953 * that replaced with the corresponding name.
954 * default_fixup_args() will then be able to convert that to the
955 * corresponding OSSL_PARAM.
957 OBJ_obj2txt(ctx->name_buf, sizeof(ctx->name_buf), ctx->p2, 0);
958 ctx->p2 = (char *)ctx->name_buf;
959 ctx->p1 = 0; /* let default_fixup_args() figure out the length */
962 if ((ret = default_fixup_args(state, translation, ctx)) <= 0)
965 if ((state == PRE_PARAMS_TO_CTRL && ctx->action_type == SET)
966 || (state == POST_CTRL_TO_PARAMS && ctx->action_type == GET)) {
968 * We're translating from ctrl to params and setting the OID name,
969 * or we're translating from params to ctrl and getting the OID
970 * name. Either way, default_fixup_args() has placed the OID name
971 * in |ctx->p2|, all we need to do now is to replace that with the
972 * corresponding ASN1_OBJECT.
974 ctx->p2 = (ASN1_OBJECT *)OBJ_txt2obj(ctx->p2, 0);
980 /* EVP_PKEY_CTRL_DH_NID */
981 static int fix_dh_nid(enum state state,
982 const struct translation_st *translation,
983 struct translation_ctx_st *ctx)
987 if ((ret = default_check(state, translation, ctx)) <= 0)
990 /* This is only settable */
991 if (ctx->action_type != SET)
994 if (state == PRE_CTRL_TO_PARAMS) {
995 ctx->p2 = (char *)ossl_ffc_named_group_get_name
996 (ossl_ffc_uid_to_dh_named_group(ctx->p1));
1000 return default_fixup_args(state, translation, ctx);
1003 /* EVP_PKEY_CTRL_DH_RFC5114 */
1004 static int fix_dh_nid5114(enum state state,
1005 const struct translation_st *translation,
1006 struct translation_ctx_st *ctx)
1010 if ((ret = default_check(state, translation, ctx)) <= 0)
1013 /* This is only settable */
1014 if (ctx->action_type != SET)
1017 if (state == PRE_CTRL_STR_TO_PARAMS) {
1018 ctx->p2 = (char *)ossl_ffc_named_group_get_name
1019 (ossl_ffc_uid_to_dh_named_group(atoi(ctx->p2)));
1023 return default_fixup_args(state, translation, ctx);
1026 /* EVP_PKEY_CTRL_DH_PARAMGEN_TYPE */
1027 static int fix_dh_paramgen_type(enum state state,
1028 const struct translation_st *translation,
1029 struct translation_ctx_st *ctx)
1033 if ((ret = default_check(state, translation, ctx)) <= 0)
1036 /* This is only settable */
1037 if (ctx->action_type != SET)
1040 if (state == PRE_CTRL_STR_TO_PARAMS) {
1041 ctx->p2 = (char *)ossl_dh_gen_type_id2name(atoi(ctx->p2));
1042 ctx->p1 = strlen(ctx->p2);
1045 return default_fixup_args(state, translation, ctx);
1048 /* EVP_PKEY_CTRL_EC_PARAM_ENC */
1049 static int fix_ec_param_enc(enum state state,
1050 const struct translation_st *translation,
1051 struct translation_ctx_st *ctx)
1055 if ((ret = default_check(state, translation, ctx)) <= 0)
1058 /* This is currently only settable */
1059 if (ctx->action_type != SET)
1062 if (state == PRE_CTRL_TO_PARAMS) {
1064 case OPENSSL_EC_EXPLICIT_CURVE:
1065 ctx->p2 = OSSL_PKEY_EC_ENCODING_EXPLICIT;
1067 case OPENSSL_EC_NAMED_CURVE:
1068 ctx->p2 = OSSL_PKEY_EC_ENCODING_GROUP;
1077 if ((ret = default_fixup_args(state, translation, ctx)) <= 0)
1080 if (state == PRE_PARAMS_TO_CTRL) {
1081 if (strcmp(ctx->p2, OSSL_PKEY_EC_ENCODING_EXPLICIT) == 0)
1082 ctx->p1 = OPENSSL_EC_EXPLICIT_CURVE;
1083 else if (strcmp(ctx->p2, OSSL_PKEY_EC_ENCODING_GROUP) == 0)
1084 ctx->p1 = OPENSSL_EC_NAMED_CURVE;
1092 ERR_raise(ERR_LIB_EVP, EVP_R_COMMAND_NOT_SUPPORTED);
1096 /* EVP_PKEY_CTRL_EC_PARAMGEN_CURVE_NID */
1097 static int fix_ec_paramgen_curve_nid(enum state state,
1098 const struct translation_st *translation,
1099 struct translation_ctx_st *ctx)
1103 if ((ret = default_check(state, translation, ctx)) <= 0)
1106 /* This is currently only settable */
1107 if (ctx->action_type != SET)
1110 if (state == PRE_CTRL_TO_PARAMS) {
1111 ctx->p2 = (char *)OBJ_nid2sn(ctx->p1);
1115 if ((ret = default_fixup_args(state, translation, ctx)) <= 0)
1118 if (state == PRE_PARAMS_TO_CTRL) {
1119 ctx->p1 = OBJ_sn2nid(ctx->p2);
1126 /* EVP_PKEY_CTRL_EC_ECDH_COFACTOR */
1127 static int fix_ecdh_cofactor(enum state state,
1128 const struct translation_st *translation,
1129 struct translation_ctx_st *ctx)
1132 * The EVP_PKEY_CTRL_EC_ECDH_COFACTOR ctrl command is a bit special, in
1133 * that it's used both for setting a value, and for getting it, all
1134 * depending on the value if |ctx->p1|; if |ctx->p1| is -2, the backend is
1135 * supposed to place the current cofactor mode in |ctx->p2|, and if not,
1136 * |ctx->p1| is interpreted as the new cofactor mode.
1140 if (state == PRE_CTRL_TO_PARAMS) {
1142 * The initial value for |ctx->action_type| must be zero.
1143 * evp_pkey_ctrl_to_params() takes it from the translation item.
1145 if (!ossl_assert(ctx->action_type == NONE))
1148 /* The action type depends on the value of ctx->p1 */
1150 ctx->action_type = GET;
1152 ctx->action_type = SET;
1153 } else if (state == PRE_CTRL_STR_TO_PARAMS) {
1154 ctx->action_type = SET;
1155 } else if (state == PRE_PARAMS_TO_CTRL) {
1156 /* The initial value for |ctx->action_type| must not be zero. */
1157 if (!ossl_assert(ctx->action_type != NONE))
1161 if ((ret = default_check(state, translation, ctx)) <= 0)
1164 if (state == PRE_CTRL_TO_PARAMS && ctx->action_type == SET) {
1165 if (ctx->p1 < -1 || ctx->p1 > 1) {
1166 /* Uses the same return value of pkey_ec_ctrl() */
1171 if ((ret = default_fixup_args(state, translation, ctx)) <= 0)
1174 if (state == POST_CTRL_TO_PARAMS && ctx->action_type == GET) {
1175 if (ctx->p1 < 0 || ctx->p1 > 1) {
1177 * The provider should return either 0 or 1, any other value is a
1182 } else if (state == PRE_PARAMS_TO_CTRL && ctx->action_type == GET) {
1189 /* EVP_PKEY_CTRL_RSA_PADDING, EVP_PKEY_CTRL_GET_RSA_PADDING */
1190 static int fix_rsa_padding_mode(enum state state,
1191 const struct translation_st *translation,
1192 struct translation_ctx_st *ctx)
1194 static const OSSL_ITEM str_value_map[] = {
1195 { RSA_PKCS1_PADDING, "pkcs1" },
1196 { RSA_NO_PADDING, "none" },
1197 { RSA_PKCS1_OAEP_PADDING, "oaep" },
1198 { RSA_PKCS1_OAEP_PADDING, "oeap" },
1199 { RSA_X931_PADDING, "x931" },
1200 { RSA_PKCS1_PSS_PADDING, "pss" },
1201 /* Special case, will pass directly as an integer */
1202 { RSA_PKCS1_WITH_TLS_PADDING, NULL }
1206 if ((ret = default_check(state, translation, ctx)) <= 0)
1209 if (state == PRE_CTRL_TO_PARAMS && ctx->action_type == GET) {
1211 * EVP_PKEY_CTRL_GET_RSA_PADDING returns the padding mode in the
1212 * weirdest way for a ctrl. Instead of doing like all other ctrls
1213 * that return a simple, i.e. just have that as a return value,
1214 * this particular ctrl treats p2 as the address for the int to be
1215 * returned. We must therefore remember |ctx->p2|, then make
1216 * |ctx->p2| point at a buffer to be filled in with the name, and
1217 * |ctx->p1| with its size. default_fixup_args() will take care
1218 * of the rest for us, along with the POST_CTRL_TO_PARAMS && GET
1219 * code section further down.
1221 ctx->orig_p2 = ctx->p2;
1222 ctx->p2 = ctx->name_buf;
1223 ctx->p1 = sizeof(ctx->name_buf);
1224 } else if (state == PRE_CTRL_TO_PARAMS && ctx->action_type == SET) {
1226 * Ideally, we should use utf8 strings for the diverse padding modes.
1227 * We only came here because someone called EVP_PKEY_CTX_ctrl(),
1228 * though, and since that can reasonably be seen as legacy code
1229 * that uses the diverse RSA macros for the padding mode, and we
1230 * know that at least our providers can handle the numeric modes,
1231 * we take the cheap route for now.
1233 * The other solution would be to match |ctx->p1| against entries
1234 * in str_value_map and pass the corresponding string. However,
1235 * since we don't have a string for RSA_PKCS1_WITH_TLS_PADDING,
1236 * we have to do this same hack at least for that one.
1238 * Since the "official" data type for the RSA padding mode is utf8
1239 * string, we cannot count on default_fixup_args(). Instead, we
1240 * build the OSSL_PARAM item ourselves and return immediately.
1242 ctx->params[0] = OSSL_PARAM_construct_int(translation->param_key,
1245 } else if (state == POST_PARAMS_TO_CTRL && ctx->action_type == GET) {
1249 * The EVP_PKEY_CTX_get_params() caller may have asked for a utf8
1250 * string, or may have asked for an integer of some sort. If they
1251 * ask for an integer, we respond directly. If not, we translate
1252 * the response from the ctrl function into a string.
1254 switch (ctx->params->data_type) {
1255 case OSSL_PARAM_INTEGER:
1256 return OSSL_PARAM_get_int(ctx->params, &ctx->p1);
1257 case OSSL_PARAM_UNSIGNED_INTEGER:
1258 return OSSL_PARAM_get_uint(ctx->params, (unsigned int *)&ctx->p1);
1263 for (i = 0; i < OSSL_NELEM(str_value_map); i++) {
1264 if (ctx->p1 == (int)str_value_map[i].id)
1267 if (i == OSSL_NELEM(str_value_map)) {
1268 ERR_raise_data(ERR_LIB_RSA, RSA_R_UNKNOWN_PADDING_TYPE,
1269 "[action:%d, state:%d] padding number %d",
1270 ctx->action_type, state, ctx->p1);
1274 * If we don't have a string, we can't do anything. The caller
1275 * should have asked for a number...
1277 if (str_value_map[i].ptr == NULL) {
1278 ERR_raise(ERR_LIB_EVP, EVP_R_COMMAND_NOT_SUPPORTED);
1281 ctx->p2 = str_value_map[i].ptr;
1282 ctx->p1 = strlen(ctx->p2);
1285 if ((ret = default_fixup_args(state, translation, ctx)) <= 0)
1288 if ((ctx->action_type == SET && state == PRE_PARAMS_TO_CTRL)
1289 || (ctx->action_type == GET && state == POST_CTRL_TO_PARAMS)) {
1292 for (i = 0; i < OSSL_NELEM(str_value_map); i++) {
1293 if (strcmp(ctx->p2, str_value_map[i].ptr) == 0)
1297 if (i == OSSL_NELEM(str_value_map)) {
1298 ERR_raise_data(ERR_LIB_RSA, RSA_R_UNKNOWN_PADDING_TYPE,
1299 "[action:%d, state:%d] padding name %s",
1300 ctx->action_type, state, ctx->p1);
1302 } else if (state == POST_CTRL_TO_PARAMS) {
1303 /* EVP_PKEY_CTRL_GET_RSA_PADDING weirdness explained further up */
1304 *(int *)ctx->orig_p2 = str_value_map[i].id;
1306 ctx->p1 = str_value_map[i].id;
1314 /* EVP_PKEY_CTRL_RSA_PSS_SALTLEN, EVP_PKEY_CTRL_GET_RSA_PSS_SALTLEN */
1315 static int fix_rsa_pss_saltlen(enum state state,
1316 const struct translation_st *translation,
1317 struct translation_ctx_st *ctx)
1319 static const OSSL_ITEM str_value_map[] = {
1320 { (unsigned int)RSA_PSS_SALTLEN_DIGEST, "digest" },
1321 { (unsigned int)RSA_PSS_SALTLEN_MAX, "max" },
1322 { (unsigned int)RSA_PSS_SALTLEN_AUTO, "auto" }
1326 if ((ret = default_check(state, translation, ctx)) <= 0)
1329 if (state == PRE_CTRL_TO_PARAMS && ctx->action_type == GET) {
1331 * EVP_PKEY_CTRL_GET_RSA_PSS_SALTLEN returns the saltlen by filling
1332 * in the int pointed at by p2. This is potentially as weird as
1333 * the way EVP_PKEY_CTRL_GET_RSA_PADDING works, except that saltlen
1334 * might be a negative value, so it wouldn't work as a legitimate
1336 * In any case, we must therefore remember |ctx->p2|, then make
1337 * |ctx->p2| point at a buffer to be filled in with the name, and
1338 * |ctx->p1| with its size. default_fixup_args() will take care
1339 * of the rest for us, along with the POST_CTRL_TO_PARAMS && GET
1340 * code section further down.
1342 ctx->orig_p2 = ctx->p2;
1343 ctx->p2 = ctx->name_buf;
1344 ctx->p1 = sizeof(ctx->name_buf);
1345 } else if ((ctx->action_type == SET && state == PRE_CTRL_TO_PARAMS)
1346 || (ctx->action_type == GET && state == POST_PARAMS_TO_CTRL)) {
1349 for (i = 0; i < OSSL_NELEM(str_value_map); i++) {
1350 if (ctx->p1 == (int)str_value_map[i].id)
1353 if (i == OSSL_NELEM(str_value_map)) {
1354 BIO_snprintf(ctx->name_buf, sizeof(ctx->name_buf), "%d", ctx->p1);
1356 /* This won't truncate but it will quiet static analysers */
1357 strncpy(ctx->name_buf, str_value_map[i].ptr, sizeof(ctx->name_buf) - 1);
1358 ctx->name_buf[sizeof(ctx->name_buf) - 1] = '\0';
1360 ctx->p2 = ctx->name_buf;
1361 ctx->p1 = strlen(ctx->p2);
1364 if ((ret = default_fixup_args(state, translation, ctx)) <= 0)
1367 if ((ctx->action_type == SET && state == PRE_PARAMS_TO_CTRL)
1368 || (ctx->action_type == GET && state == POST_CTRL_TO_PARAMS)) {
1371 for (i = 0; i < OSSL_NELEM(str_value_map); i++) {
1372 if (strcmp(ctx->p2, str_value_map[i].ptr) == 0)
1375 if (i == OSSL_NELEM(str_value_map)) {
1376 ctx->p1 = atoi(ctx->p2);
1377 } else if (state == POST_CTRL_TO_PARAMS) {
1379 * EVP_PKEY_CTRL_GET_RSA_PSS_SALTLEN weirdness explained further
1382 *(int *)ctx->orig_p2 = str_value_map[i].id;
1384 ctx->p1 = (int)str_value_map[i].id;
1392 /* EVP_PKEY_CTRL_HKDF_MODE */
1393 static int fix_hkdf_mode(enum state state,
1394 const struct translation_st *translation,
1395 struct translation_ctx_st *ctx)
1397 static const OSSL_ITEM str_value_map[] = {
1398 { EVP_KDF_HKDF_MODE_EXTRACT_AND_EXPAND, "EXTRACT_AND_EXPAND" },
1399 { EVP_KDF_HKDF_MODE_EXTRACT_ONLY, "EXTRACT_ONLY" },
1400 { EVP_KDF_HKDF_MODE_EXPAND_ONLY, "EXPAND_ONLY" }
1404 if ((ret = default_check(state, translation, ctx)) <= 0)
1407 if ((ctx->action_type == SET && state == PRE_CTRL_TO_PARAMS)
1408 || (ctx->action_type == GET && state == POST_PARAMS_TO_CTRL)) {
1411 for (i = 0; i < OSSL_NELEM(str_value_map); i++) {
1412 if (ctx->p1 == (int)str_value_map[i].id)
1415 if (i == OSSL_NELEM(str_value_map))
1417 ctx->p2 = str_value_map[i].ptr;
1418 ctx->p1 = strlen(ctx->p2);
1421 if ((ret = default_fixup_args(state, translation, ctx)) <= 0)
1424 if ((ctx->action_type == SET && state == PRE_PARAMS_TO_CTRL)
1425 || (ctx->action_type == GET && state == POST_CTRL_TO_PARAMS)) {
1428 for (i = 0; i < OSSL_NELEM(str_value_map); i++) {
1429 if (strcmp(ctx->p2, str_value_map[i].ptr) == 0)
1432 if (i == OSSL_NELEM(str_value_map))
1434 if (state == POST_CTRL_TO_PARAMS)
1435 ret = str_value_map[i].id;
1437 ctx->p1 = str_value_map[i].id;
1448 * These all get the data they want, then call default_fixup_args() as
1449 * a post-ctrl GET fixup. They all get NULL ctx, ctrl_cmd, ctrl_str,
1453 /* Pilfering DH, DSA and EC_KEY */
1454 static int get_payload_group_name(enum state state,
1455 const struct translation_st *translation,
1456 struct translation_ctx_st *ctx)
1458 EVP_PKEY *pkey = ctx->p2;
1461 switch (EVP_PKEY_get_base_id(pkey)) {
1462 #ifndef OPENSSL_NO_DH
1465 const DH *dh = EVP_PKEY_get0_DH(pkey);
1466 int uid = DH_get_nid(dh);
1468 if (uid != NID_undef) {
1469 const DH_NAMED_GROUP *dh_group =
1470 ossl_ffc_uid_to_dh_named_group(uid);
1472 ctx->p2 = (char *)ossl_ffc_named_group_get_name(dh_group);
1477 #ifndef OPENSSL_NO_EC
1480 const EC_GROUP *grp =
1481 EC_KEY_get0_group(EVP_PKEY_get0_EC_KEY(pkey));
1482 int nid = NID_undef;
1485 nid = EC_GROUP_get_curve_name(grp);
1486 if (nid != NID_undef)
1487 ctx->p2 = (char *)OSSL_EC_curve_nid2name(nid);
1492 ERR_raise(ERR_LIB_EVP, EVP_R_UNSUPPORTED_KEY_TYPE);
1497 * Quietly ignoring unknown groups matches the behaviour on the provider
1500 if (ctx->p2 == NULL)
1503 ctx->p1 = strlen(ctx->p2);
1504 return default_fixup_args(state, translation, ctx);
1507 static int get_payload_private_key(enum state state,
1508 const struct translation_st *translation,
1509 struct translation_ctx_st *ctx)
1511 EVP_PKEY *pkey = ctx->p2;
1514 if (ctx->params->data_type != OSSL_PARAM_UNSIGNED_INTEGER)
1517 switch (EVP_PKEY_get_base_id(pkey)) {
1518 #ifndef OPENSSL_NO_DH
1521 const DH *dh = EVP_PKEY_get0_DH(pkey);
1523 ctx->p2 = (BIGNUM *)DH_get0_priv_key(dh);
1527 #ifndef OPENSSL_NO_EC
1530 const EC_KEY *ec = EVP_PKEY_get0_EC_KEY(pkey);
1532 ctx->p2 = (BIGNUM *)EC_KEY_get0_private_key(ec);
1537 ERR_raise(ERR_LIB_EVP, EVP_R_UNSUPPORTED_KEY_TYPE);
1541 return default_fixup_args(state, translation, ctx);
1544 static int get_payload_public_key(enum state state,
1545 const struct translation_st *translation,
1546 struct translation_ctx_st *ctx)
1548 EVP_PKEY *pkey = ctx->p2;
1549 unsigned char *buf = NULL;
1553 switch (EVP_PKEY_get_base_id(pkey)) {
1554 #ifndef OPENSSL_NO_DH
1556 switch (ctx->params->data_type) {
1557 case OSSL_PARAM_OCTET_STRING:
1558 ctx->sz = ossl_dh_key2buf(EVP_PKEY_get0_DH(pkey), &buf, 0, 1);
1561 case OSSL_PARAM_UNSIGNED_INTEGER:
1562 ctx->p2 = (void *)DH_get0_pub_key(EVP_PKEY_get0_DH(pkey));
1569 #ifndef OPENSSL_NO_DSA
1571 if (ctx->params->data_type == OSSL_PARAM_UNSIGNED_INTEGER) {
1572 ctx->p2 = (void *)DSA_get0_pub_key(EVP_PKEY_get0_DSA(pkey));
1577 #ifndef OPENSSL_NO_EC
1579 if (ctx->params->data_type == OSSL_PARAM_OCTET_STRING) {
1580 const EC_KEY *eckey = EVP_PKEY_get0_EC_KEY(pkey);
1581 BN_CTX *bnctx = BN_CTX_new_ex(ossl_ec_key_get_libctx(eckey));
1582 const EC_GROUP *ecg = EC_KEY_get0_group(eckey);
1583 const EC_POINT *point = EC_KEY_get0_public_key(eckey);
1585 ctx->sz = EC_POINT_point2buf(ecg, point,
1586 POINT_CONVERSION_COMPRESSED,
1594 ERR_raise(ERR_LIB_EVP, EVP_R_UNSUPPORTED_KEY_TYPE);
1598 ret = default_fixup_args(state, translation, ctx);
1603 static int get_payload_bn(enum state state,
1604 const struct translation_st *translation,
1605 struct translation_ctx_st *ctx, const BIGNUM *bn)
1609 if (ctx->params->data_type != OSSL_PARAM_UNSIGNED_INTEGER)
1611 ctx->p2 = (BIGNUM *)bn;
1613 return default_fixup_args(state, translation, ctx);
1616 static int get_dh_dsa_payload_p(enum state state,
1617 const struct translation_st *translation,
1618 struct translation_ctx_st *ctx)
1620 const BIGNUM *bn = NULL;
1621 EVP_PKEY *pkey = ctx->p2;
1623 switch (EVP_PKEY_get_base_id(pkey)) {
1624 #ifndef OPENSSL_NO_DH
1626 bn = DH_get0_p(EVP_PKEY_get0_DH(pkey));
1629 #ifndef OPENSSL_NO_DSA
1631 bn = DSA_get0_p(EVP_PKEY_get0_DSA(pkey));
1635 ERR_raise(ERR_LIB_EVP, EVP_R_UNSUPPORTED_KEY_TYPE);
1638 return get_payload_bn(state, translation, ctx, bn);
1641 static int get_dh_dsa_payload_q(enum state state,
1642 const struct translation_st *translation,
1643 struct translation_ctx_st *ctx)
1645 const BIGNUM *bn = NULL;
1647 switch (EVP_PKEY_get_base_id(ctx->p2)) {
1648 #ifndef OPENSSL_NO_DH
1650 bn = DH_get0_q(EVP_PKEY_get0_DH(ctx->p2));
1653 #ifndef OPENSSL_NO_DSA
1655 bn = DSA_get0_q(EVP_PKEY_get0_DSA(ctx->p2));
1660 return get_payload_bn(state, translation, ctx, bn);
1663 static int get_dh_dsa_payload_g(enum state state,
1664 const struct translation_st *translation,
1665 struct translation_ctx_st *ctx)
1667 const BIGNUM *bn = NULL;
1669 switch (EVP_PKEY_get_base_id(ctx->p2)) {
1670 #ifndef OPENSSL_NO_DH
1672 bn = DH_get0_g(EVP_PKEY_get0_DH(ctx->p2));
1675 #ifndef OPENSSL_NO_DSA
1677 bn = DSA_get0_g(EVP_PKEY_get0_DSA(ctx->p2));
1682 return get_payload_bn(state, translation, ctx, bn);
1685 static int get_payload_int(enum state state,
1686 const struct translation_st *translation,
1687 struct translation_ctx_st *ctx,
1690 if (ctx->params->data_type != OSSL_PARAM_INTEGER)
1695 return default_fixup_args(state, translation, ctx);
1698 static int get_ec_decoded_from_explicit_params(enum state state,
1699 const struct translation_st *translation,
1700 struct translation_ctx_st *ctx)
1703 EVP_PKEY *pkey = ctx->p2;
1705 switch (EVP_PKEY_base_id(pkey)) {
1706 #ifndef OPENSSL_NO_EC
1708 val = EC_KEY_decoded_from_explicit_params(EVP_PKEY_get0_EC_KEY(pkey));
1710 ERR_raise(ERR_LIB_EVP, EVP_R_INVALID_KEY);
1716 ERR_raise(ERR_LIB_EVP, EVP_R_UNSUPPORTED_KEY_TYPE);
1720 return get_payload_int(state, translation, ctx, val);
1723 static int get_rsa_payload_n(enum state state,
1724 const struct translation_st *translation,
1725 struct translation_ctx_st *ctx)
1727 const BIGNUM *bn = NULL;
1729 if (EVP_PKEY_get_base_id(ctx->p2) != EVP_PKEY_RSA)
1731 bn = RSA_get0_n(EVP_PKEY_get0_RSA(ctx->p2));
1733 return get_payload_bn(state, translation, ctx, bn);
1736 static int get_rsa_payload_e(enum state state,
1737 const struct translation_st *translation,
1738 struct translation_ctx_st *ctx)
1740 const BIGNUM *bn = NULL;
1742 if (EVP_PKEY_get_base_id(ctx->p2) != EVP_PKEY_RSA)
1744 bn = RSA_get0_e(EVP_PKEY_get0_RSA(ctx->p2));
1746 return get_payload_bn(state, translation, ctx, bn);
1749 static int get_rsa_payload_d(enum state state,
1750 const struct translation_st *translation,
1751 struct translation_ctx_st *ctx)
1753 const BIGNUM *bn = NULL;
1755 if (EVP_PKEY_get_base_id(ctx->p2) != EVP_PKEY_RSA)
1757 bn = RSA_get0_d(EVP_PKEY_get0_RSA(ctx->p2));
1759 return get_payload_bn(state, translation, ctx, bn);
1762 static int get_rsa_payload_factor(enum state state,
1763 const struct translation_st *translation,
1764 struct translation_ctx_st *ctx,
1767 const RSA *r = EVP_PKEY_get0_RSA(ctx->p2);
1768 const BIGNUM *bn = NULL;
1770 switch (factornum) {
1779 size_t pnum = RSA_get_multi_prime_extra_count(r);
1780 const BIGNUM *factors[10];
1782 if (factornum - 2 < pnum
1783 && RSA_get0_multi_prime_factors(r, factors))
1784 bn = factors[factornum - 2];
1789 return get_payload_bn(state, translation, ctx, bn);
1792 static int get_rsa_payload_exponent(enum state state,
1793 const struct translation_st *translation,
1794 struct translation_ctx_st *ctx,
1797 const RSA *r = EVP_PKEY_get0_RSA(ctx->p2);
1798 const BIGNUM *bn = NULL;
1800 switch (exponentnum) {
1802 bn = RSA_get0_dmp1(r);
1805 bn = RSA_get0_dmq1(r);
1809 size_t pnum = RSA_get_multi_prime_extra_count(r);
1810 const BIGNUM *exps[10], *coeffs[10];
1812 if (exponentnum - 2 < pnum
1813 && RSA_get0_multi_prime_crt_params(r, exps, coeffs))
1814 bn = exps[exponentnum - 2];
1819 return get_payload_bn(state, translation, ctx, bn);
1822 static int get_rsa_payload_coefficient(enum state state,
1823 const struct translation_st *translation,
1824 struct translation_ctx_st *ctx,
1825 size_t coefficientnum)
1827 const RSA *r = EVP_PKEY_get0_RSA(ctx->p2);
1828 const BIGNUM *bn = NULL;
1830 switch (coefficientnum) {
1832 bn = RSA_get0_iqmp(r);
1836 size_t pnum = RSA_get_multi_prime_extra_count(r);
1837 const BIGNUM *exps[10], *coeffs[10];
1839 if (coefficientnum - 1 < pnum
1840 && RSA_get0_multi_prime_crt_params(r, exps, coeffs))
1841 bn = coeffs[coefficientnum - 1];
1846 return get_payload_bn(state, translation, ctx, bn);
1849 #define IMPL_GET_RSA_PAYLOAD_FACTOR(n) \
1851 get_rsa_payload_f##n(enum state state, \
1852 const struct translation_st *translation, \
1853 struct translation_ctx_st *ctx) \
1855 if (EVP_PKEY_get_base_id(ctx->p2) != EVP_PKEY_RSA) \
1857 return get_rsa_payload_factor(state, translation, ctx, n - 1); \
1860 #define IMPL_GET_RSA_PAYLOAD_EXPONENT(n) \
1862 get_rsa_payload_e##n(enum state state, \
1863 const struct translation_st *translation, \
1864 struct translation_ctx_st *ctx) \
1866 if (EVP_PKEY_get_base_id(ctx->p2) != EVP_PKEY_RSA) \
1868 return get_rsa_payload_exponent(state, translation, ctx, \
1872 #define IMPL_GET_RSA_PAYLOAD_COEFFICIENT(n) \
1874 get_rsa_payload_c##n(enum state state, \
1875 const struct translation_st *translation, \
1876 struct translation_ctx_st *ctx) \
1878 if (EVP_PKEY_get_base_id(ctx->p2) != EVP_PKEY_RSA) \
1880 return get_rsa_payload_coefficient(state, translation, ctx, \
1884 IMPL_GET_RSA_PAYLOAD_FACTOR(1)
1885 IMPL_GET_RSA_PAYLOAD_FACTOR(2)
1886 IMPL_GET_RSA_PAYLOAD_FACTOR(3)
1887 IMPL_GET_RSA_PAYLOAD_FACTOR(4)
1888 IMPL_GET_RSA_PAYLOAD_FACTOR(5)
1889 IMPL_GET_RSA_PAYLOAD_FACTOR(6)
1890 IMPL_GET_RSA_PAYLOAD_FACTOR(7)
1891 IMPL_GET_RSA_PAYLOAD_FACTOR(8)
1892 IMPL_GET_RSA_PAYLOAD_FACTOR(9)
1893 IMPL_GET_RSA_PAYLOAD_FACTOR(10)
1894 IMPL_GET_RSA_PAYLOAD_EXPONENT(1)
1895 IMPL_GET_RSA_PAYLOAD_EXPONENT(2)
1896 IMPL_GET_RSA_PAYLOAD_EXPONENT(3)
1897 IMPL_GET_RSA_PAYLOAD_EXPONENT(4)
1898 IMPL_GET_RSA_PAYLOAD_EXPONENT(5)
1899 IMPL_GET_RSA_PAYLOAD_EXPONENT(6)
1900 IMPL_GET_RSA_PAYLOAD_EXPONENT(7)
1901 IMPL_GET_RSA_PAYLOAD_EXPONENT(8)
1902 IMPL_GET_RSA_PAYLOAD_EXPONENT(9)
1903 IMPL_GET_RSA_PAYLOAD_EXPONENT(10)
1904 IMPL_GET_RSA_PAYLOAD_COEFFICIENT(1)
1905 IMPL_GET_RSA_PAYLOAD_COEFFICIENT(2)
1906 IMPL_GET_RSA_PAYLOAD_COEFFICIENT(3)
1907 IMPL_GET_RSA_PAYLOAD_COEFFICIENT(4)
1908 IMPL_GET_RSA_PAYLOAD_COEFFICIENT(5)
1909 IMPL_GET_RSA_PAYLOAD_COEFFICIENT(6)
1910 IMPL_GET_RSA_PAYLOAD_COEFFICIENT(7)
1911 IMPL_GET_RSA_PAYLOAD_COEFFICIENT(8)
1912 IMPL_GET_RSA_PAYLOAD_COEFFICIENT(9)
1915 * The translation table itself
1916 * ============================
1919 static const struct translation_st evp_pkey_ctx_translations[] = {
1921 * DistID: we pass it to the backend as an octet string,
1922 * but get it back as a pointer to an octet string.
1924 * Note that the EVP_PKEY_CTRL_GET1_ID_LEN is purely for legacy purposes
1925 * that has no separate counterpart in OSSL_PARAM terms, since we get
1926 * the length of the DistID automatically when getting the DistID itself.
1928 { SET, -1, -1, EVP_PKEY_OP_TYPE_SIG,
1929 EVP_PKEY_CTRL_SET1_ID, "distid", "hexdistid",
1930 OSSL_PKEY_PARAM_DIST_ID, OSSL_PARAM_OCTET_STRING, NULL },
1932 EVP_PKEY_CTRL_GET1_ID, "distid", "hexdistid",
1933 OSSL_PKEY_PARAM_DIST_ID, OSSL_PARAM_OCTET_PTR, NULL },
1935 EVP_PKEY_CTRL_GET1_ID_LEN, NULL, NULL,
1936 OSSL_PKEY_PARAM_DIST_ID, OSSL_PARAM_OCTET_PTR, fix_distid_len },
1944 * EVP_PKEY_CTRL_DH_KDF_TYPE is used both for setting and getting. The
1945 * fixup function has to handle this...
1947 { NONE, EVP_PKEY_DHX, 0, EVP_PKEY_OP_DERIVE,
1948 EVP_PKEY_CTRL_DH_KDF_TYPE, NULL, NULL,
1949 OSSL_EXCHANGE_PARAM_KDF_TYPE, OSSL_PARAM_UTF8_STRING,
1951 { SET, EVP_PKEY_DHX, 0, EVP_PKEY_OP_DERIVE,
1952 EVP_PKEY_CTRL_DH_KDF_MD, NULL, NULL,
1953 OSSL_EXCHANGE_PARAM_KDF_DIGEST, OSSL_PARAM_UTF8_STRING, fix_md },
1954 { GET, EVP_PKEY_DHX, 0, EVP_PKEY_OP_DERIVE,
1955 EVP_PKEY_CTRL_GET_DH_KDF_MD, NULL, NULL,
1956 OSSL_EXCHANGE_PARAM_KDF_DIGEST, OSSL_PARAM_UTF8_STRING, fix_md },
1957 { SET, EVP_PKEY_DHX, 0, EVP_PKEY_OP_DERIVE,
1958 EVP_PKEY_CTRL_DH_KDF_OUTLEN, NULL, NULL,
1959 OSSL_EXCHANGE_PARAM_KDF_OUTLEN, OSSL_PARAM_UNSIGNED_INTEGER, NULL },
1960 { GET, EVP_PKEY_DHX, 0, EVP_PKEY_OP_DERIVE,
1961 EVP_PKEY_CTRL_GET_DH_KDF_OUTLEN, NULL, NULL,
1962 OSSL_EXCHANGE_PARAM_KDF_OUTLEN, OSSL_PARAM_UNSIGNED_INTEGER, NULL },
1963 { SET, EVP_PKEY_DHX, 0, EVP_PKEY_OP_DERIVE,
1964 EVP_PKEY_CTRL_DH_KDF_UKM, NULL, NULL,
1965 OSSL_EXCHANGE_PARAM_KDF_UKM, OSSL_PARAM_OCTET_STRING, NULL },
1966 { GET, EVP_PKEY_DHX, 0, EVP_PKEY_OP_DERIVE,
1967 EVP_PKEY_CTRL_GET_DH_KDF_UKM, NULL, NULL,
1968 OSSL_EXCHANGE_PARAM_KDF_UKM, OSSL_PARAM_OCTET_PTR, NULL },
1969 { SET, EVP_PKEY_DHX, 0, EVP_PKEY_OP_DERIVE,
1970 EVP_PKEY_CTRL_DH_KDF_OID, NULL, NULL,
1971 OSSL_KDF_PARAM_CEK_ALG, OSSL_PARAM_UTF8_STRING, fix_oid },
1972 { GET, EVP_PKEY_DHX, 0, EVP_PKEY_OP_DERIVE,
1973 EVP_PKEY_CTRL_GET_DH_KDF_OID, NULL, NULL,
1974 OSSL_KDF_PARAM_CEK_ALG, OSSL_PARAM_UTF8_STRING, fix_oid },
1976 /* DHX Keygen Parameters that are shared with DH */
1977 { SET, EVP_PKEY_DHX, 0, EVP_PKEY_OP_PARAMGEN,
1978 EVP_PKEY_CTRL_DH_PARAMGEN_TYPE, "dh_paramgen_type", NULL,
1979 OSSL_PKEY_PARAM_FFC_TYPE, OSSL_PARAM_UTF8_STRING, fix_dh_paramgen_type },
1980 { SET, EVP_PKEY_DHX, 0, EVP_PKEY_OP_PARAMGEN,
1981 EVP_PKEY_CTRL_DH_PARAMGEN_PRIME_LEN, "dh_paramgen_prime_len", NULL,
1982 OSSL_PKEY_PARAM_FFC_PBITS, OSSL_PARAM_UNSIGNED_INTEGER, NULL },
1983 { SET, EVP_PKEY_DHX, 0, EVP_PKEY_OP_PARAMGEN | EVP_PKEY_OP_KEYGEN,
1984 EVP_PKEY_CTRL_DH_NID, "dh_param", NULL,
1985 OSSL_PKEY_PARAM_GROUP_NAME, OSSL_PARAM_UTF8_STRING, NULL },
1986 { SET, EVP_PKEY_DHX, 0, EVP_PKEY_OP_PARAMGEN | EVP_PKEY_OP_KEYGEN,
1987 EVP_PKEY_CTRL_DH_RFC5114, "dh_rfc5114", NULL,
1988 OSSL_PKEY_PARAM_GROUP_NAME, OSSL_PARAM_UTF8_STRING, fix_dh_nid5114 },
1990 /* DH Keygen Parameters that are shared with DHX */
1991 { SET, EVP_PKEY_DH, 0, EVP_PKEY_OP_PARAMGEN,
1992 EVP_PKEY_CTRL_DH_PARAMGEN_TYPE, "dh_paramgen_type", NULL,
1993 OSSL_PKEY_PARAM_FFC_TYPE, OSSL_PARAM_UTF8_STRING, fix_dh_paramgen_type },
1994 { SET, EVP_PKEY_DH, 0, EVP_PKEY_OP_PARAMGEN,
1995 EVP_PKEY_CTRL_DH_PARAMGEN_PRIME_LEN, "dh_paramgen_prime_len", NULL,
1996 OSSL_PKEY_PARAM_FFC_PBITS, OSSL_PARAM_UNSIGNED_INTEGER, NULL },
1997 { SET, EVP_PKEY_DH, 0, EVP_PKEY_OP_PARAMGEN | EVP_PKEY_OP_KEYGEN,
1998 EVP_PKEY_CTRL_DH_NID, "dh_param", NULL,
1999 OSSL_PKEY_PARAM_GROUP_NAME, OSSL_PARAM_UTF8_STRING, fix_dh_nid },
2000 { SET, EVP_PKEY_DH, 0, EVP_PKEY_OP_PARAMGEN | EVP_PKEY_OP_KEYGEN,
2001 EVP_PKEY_CTRL_DH_RFC5114, "dh_rfc5114", NULL,
2002 OSSL_PKEY_PARAM_GROUP_NAME, OSSL_PARAM_UTF8_STRING, fix_dh_nid5114 },
2004 /* DH specific Keygen Parameters */
2005 { SET, EVP_PKEY_DH, 0, EVP_PKEY_OP_PARAMGEN,
2006 EVP_PKEY_CTRL_DH_PARAMGEN_GENERATOR, "dh_paramgen_generator", NULL,
2007 OSSL_PKEY_PARAM_DH_GENERATOR, OSSL_PARAM_INTEGER, NULL },
2009 /* DHX specific Keygen Parameters */
2010 { SET, EVP_PKEY_DHX, 0, EVP_PKEY_OP_PARAMGEN,
2011 EVP_PKEY_CTRL_DH_PARAMGEN_SUBPRIME_LEN, "dh_paramgen_subprime_len", NULL,
2012 OSSL_PKEY_PARAM_FFC_QBITS, OSSL_PARAM_UNSIGNED_INTEGER, NULL },
2014 { SET, EVP_PKEY_DH, 0, EVP_PKEY_OP_DERIVE,
2015 EVP_PKEY_CTRL_DH_PAD, "dh_pad", NULL,
2016 OSSL_EXCHANGE_PARAM_PAD, OSSL_PARAM_UNSIGNED_INTEGER, NULL },
2022 { SET, EVP_PKEY_DSA, 0, EVP_PKEY_OP_PARAMGEN,
2023 EVP_PKEY_CTRL_DSA_PARAMGEN_BITS, "dsa_paramgen_bits", NULL,
2024 OSSL_PKEY_PARAM_FFC_PBITS, OSSL_PARAM_UNSIGNED_INTEGER, NULL },
2025 { SET, EVP_PKEY_DSA, 0, EVP_PKEY_OP_PARAMGEN,
2026 EVP_PKEY_CTRL_DSA_PARAMGEN_Q_BITS, "dsa_paramgen_q_bits", NULL,
2027 OSSL_PKEY_PARAM_FFC_QBITS, OSSL_PARAM_UNSIGNED_INTEGER, NULL },
2028 { SET, EVP_PKEY_DSA, 0, EVP_PKEY_OP_PARAMGEN,
2029 EVP_PKEY_CTRL_DSA_PARAMGEN_MD, "dsa_paramgen_md", NULL,
2030 OSSL_PKEY_PARAM_FFC_DIGEST, OSSL_PARAM_UTF8_STRING, fix_md },
2036 { SET, EVP_PKEY_EC, 0, EVP_PKEY_OP_PARAMGEN | EVP_PKEY_OP_KEYGEN,
2037 EVP_PKEY_CTRL_EC_PARAM_ENC, "ec_param_enc", NULL,
2038 OSSL_PKEY_PARAM_EC_ENCODING, OSSL_PARAM_UTF8_STRING, fix_ec_param_enc },
2039 { SET, EVP_PKEY_EC, 0, EVP_PKEY_OP_PARAMGEN | EVP_PKEY_OP_KEYGEN,
2040 EVP_PKEY_CTRL_EC_PARAMGEN_CURVE_NID, "ec_paramgen_curve", NULL,
2041 OSSL_PKEY_PARAM_GROUP_NAME, OSSL_PARAM_UTF8_STRING,
2042 fix_ec_paramgen_curve_nid },
2044 * EVP_PKEY_CTRL_EC_ECDH_COFACTOR and EVP_PKEY_CTRL_EC_KDF_TYPE are used
2045 * both for setting and getting. The fixup function has to handle this...
2047 { NONE, EVP_PKEY_EC, 0, EVP_PKEY_OP_DERIVE,
2048 EVP_PKEY_CTRL_EC_ECDH_COFACTOR, "ecdh_cofactor_mode", NULL,
2049 OSSL_EXCHANGE_PARAM_EC_ECDH_COFACTOR_MODE, OSSL_PARAM_INTEGER,
2050 fix_ecdh_cofactor },
2051 { NONE, EVP_PKEY_EC, 0, EVP_PKEY_OP_DERIVE,
2052 EVP_PKEY_CTRL_EC_KDF_TYPE, NULL, NULL,
2053 OSSL_EXCHANGE_PARAM_KDF_TYPE, OSSL_PARAM_UTF8_STRING, fix_ec_kdf_type },
2054 { SET, EVP_PKEY_EC, 0, EVP_PKEY_OP_DERIVE,
2055 EVP_PKEY_CTRL_EC_KDF_MD, "ecdh_kdf_md", NULL,
2056 OSSL_EXCHANGE_PARAM_KDF_DIGEST, OSSL_PARAM_UTF8_STRING, fix_md },
2057 { GET, EVP_PKEY_EC, 0, EVP_PKEY_OP_DERIVE,
2058 EVP_PKEY_CTRL_GET_EC_KDF_MD, NULL, NULL,
2059 OSSL_EXCHANGE_PARAM_KDF_DIGEST, OSSL_PARAM_UTF8_STRING, fix_md },
2060 { SET, EVP_PKEY_EC, 0, EVP_PKEY_OP_DERIVE,
2061 EVP_PKEY_CTRL_EC_KDF_OUTLEN, NULL, NULL,
2062 OSSL_EXCHANGE_PARAM_KDF_OUTLEN, OSSL_PARAM_UNSIGNED_INTEGER, NULL },
2063 { GET, EVP_PKEY_EC, 0, EVP_PKEY_OP_DERIVE,
2064 EVP_PKEY_CTRL_GET_EC_KDF_OUTLEN, NULL, NULL,
2065 OSSL_EXCHANGE_PARAM_KDF_OUTLEN, OSSL_PARAM_UNSIGNED_INTEGER, NULL },
2066 { SET, EVP_PKEY_EC, 0, EVP_PKEY_OP_DERIVE,
2067 EVP_PKEY_CTRL_EC_KDF_UKM, NULL, NULL,
2068 OSSL_EXCHANGE_PARAM_KDF_UKM, OSSL_PARAM_OCTET_STRING, NULL },
2069 { GET, EVP_PKEY_EC, 0, EVP_PKEY_OP_DERIVE,
2070 EVP_PKEY_CTRL_GET_EC_KDF_UKM, NULL, NULL,
2071 OSSL_EXCHANGE_PARAM_KDF_UKM, OSSL_PARAM_OCTET_PTR, NULL },
2079 * RSA padding modes are numeric with ctrls, strings with ctrl_strs,
2080 * and can be both with OSSL_PARAM. We standardise on strings here,
2081 * fix_rsa_padding_mode() does the work when the caller has a different
2084 { SET, EVP_PKEY_RSA, EVP_PKEY_RSA_PSS,
2085 EVP_PKEY_OP_TYPE_CRYPT | EVP_PKEY_OP_TYPE_SIG,
2086 EVP_PKEY_CTRL_RSA_PADDING, "rsa_padding_mode", NULL,
2087 OSSL_PKEY_PARAM_PAD_MODE, OSSL_PARAM_UTF8_STRING, fix_rsa_padding_mode },
2088 { GET, EVP_PKEY_RSA, EVP_PKEY_RSA_PSS,
2089 EVP_PKEY_OP_TYPE_CRYPT | EVP_PKEY_OP_TYPE_SIG,
2090 EVP_PKEY_CTRL_GET_RSA_PADDING, NULL, NULL,
2091 OSSL_PKEY_PARAM_PAD_MODE, OSSL_PARAM_UTF8_STRING, fix_rsa_padding_mode },
2093 { SET, EVP_PKEY_RSA, EVP_PKEY_RSA_PSS,
2094 EVP_PKEY_OP_TYPE_CRYPT | EVP_PKEY_OP_TYPE_SIG,
2095 EVP_PKEY_CTRL_RSA_MGF1_MD, "rsa_mgf1_md", NULL,
2096 OSSL_PKEY_PARAM_MGF1_DIGEST, OSSL_PARAM_UTF8_STRING, fix_md },
2097 { GET, EVP_PKEY_RSA, EVP_PKEY_RSA_PSS,
2098 EVP_PKEY_OP_TYPE_CRYPT | EVP_PKEY_OP_TYPE_SIG,
2099 EVP_PKEY_CTRL_GET_RSA_MGF1_MD, NULL, NULL,
2100 OSSL_PKEY_PARAM_MGF1_DIGEST, OSSL_PARAM_UTF8_STRING, fix_md },
2103 * RSA-PSS saltlen is essentially numeric, but certain values can be
2104 * expressed as keywords (strings) with ctrl_str. The corresponding
2105 * OSSL_PARAM allows both forms.
2106 * fix_rsa_pss_saltlen() takes care of the distinction.
2108 { SET, EVP_PKEY_RSA, EVP_PKEY_RSA_PSS, EVP_PKEY_OP_TYPE_SIG,
2109 EVP_PKEY_CTRL_RSA_PSS_SALTLEN, "rsa_pss_saltlen", NULL,
2110 OSSL_PKEY_PARAM_RSA_PSS_SALTLEN, OSSL_PARAM_UTF8_STRING,
2111 fix_rsa_pss_saltlen },
2112 { GET, EVP_PKEY_RSA, EVP_PKEY_RSA_PSS, EVP_PKEY_OP_TYPE_SIG,
2113 EVP_PKEY_CTRL_GET_RSA_PSS_SALTLEN, NULL, NULL,
2114 OSSL_PKEY_PARAM_RSA_PSS_SALTLEN, OSSL_PARAM_UTF8_STRING,
2115 fix_rsa_pss_saltlen },
2117 { SET, EVP_PKEY_RSA, 0, EVP_PKEY_OP_TYPE_CRYPT,
2118 EVP_PKEY_CTRL_RSA_OAEP_MD, "rsa_oaep_md", NULL,
2119 OSSL_ASYM_CIPHER_PARAM_OAEP_DIGEST, OSSL_PARAM_UTF8_STRING, fix_md },
2120 { GET, EVP_PKEY_RSA, 0, EVP_PKEY_OP_TYPE_CRYPT,
2121 EVP_PKEY_CTRL_GET_RSA_OAEP_MD, NULL, NULL,
2122 OSSL_ASYM_CIPHER_PARAM_OAEP_DIGEST, OSSL_PARAM_UTF8_STRING, fix_md },
2124 * The "rsa_oaep_label" ctrl_str expects the value to always be hex.
2125 * This is accomodated by default_fixup_args() above, which mimics that
2126 * expectation for any translation item where |ctrl_str| is NULL and
2127 * |ctrl_hexstr| is non-NULL.
2129 { SET, EVP_PKEY_RSA, 0, EVP_PKEY_OP_TYPE_CRYPT,
2130 EVP_PKEY_CTRL_RSA_OAEP_LABEL, NULL, "rsa_oaep_label",
2131 OSSL_ASYM_CIPHER_PARAM_OAEP_LABEL, OSSL_PARAM_OCTET_STRING, NULL },
2132 { GET, EVP_PKEY_RSA, 0, EVP_PKEY_OP_TYPE_CRYPT,
2133 EVP_PKEY_CTRL_GET_RSA_OAEP_LABEL, NULL, NULL,
2134 OSSL_ASYM_CIPHER_PARAM_OAEP_LABEL, OSSL_PARAM_OCTET_STRING, NULL },
2136 { SET, EVP_PKEY_RSA_PSS, 0, EVP_PKEY_OP_TYPE_GEN,
2137 EVP_PKEY_CTRL_MD, "rsa_pss_keygen_md", NULL,
2138 OSSL_ALG_PARAM_DIGEST, OSSL_PARAM_UTF8_STRING, fix_md },
2139 { SET, EVP_PKEY_RSA_PSS, 0, EVP_PKEY_OP_TYPE_GEN,
2140 EVP_PKEY_CTRL_RSA_MGF1_MD, "rsa_pss_keygen_mgf1_md", NULL,
2141 OSSL_PKEY_PARAM_MGF1_DIGEST, OSSL_PARAM_UTF8_STRING, fix_md },
2142 { SET, EVP_PKEY_RSA_PSS, 0, EVP_PKEY_OP_TYPE_GEN,
2143 EVP_PKEY_CTRL_RSA_PSS_SALTLEN, "rsa_pss_keygen_saltlen", NULL,
2144 OSSL_SIGNATURE_PARAM_PSS_SALTLEN, OSSL_PARAM_INTEGER, NULL },
2145 { SET, EVP_PKEY_RSA, EVP_PKEY_RSA_PSS, EVP_PKEY_OP_KEYGEN,
2146 EVP_PKEY_CTRL_RSA_KEYGEN_BITS, "rsa_keygen_bits", NULL,
2147 OSSL_PKEY_PARAM_RSA_BITS, OSSL_PARAM_UNSIGNED_INTEGER, NULL },
2148 { SET, EVP_PKEY_RSA, 0, EVP_PKEY_OP_KEYGEN,
2149 EVP_PKEY_CTRL_RSA_KEYGEN_PUBEXP, "rsa_keygen_pubexp", NULL,
2150 OSSL_PKEY_PARAM_RSA_E, OSSL_PARAM_UNSIGNED_INTEGER, NULL },
2151 { SET, EVP_PKEY_RSA, 0, EVP_PKEY_OP_KEYGEN,
2152 EVP_PKEY_CTRL_RSA_KEYGEN_PRIMES, "rsa_keygen_primes", NULL,
2153 OSSL_PKEY_PARAM_RSA_PRIMES, OSSL_PARAM_UNSIGNED_INTEGER, NULL },
2159 { SET, -1, -1, EVP_PKEY_OP_TYPE_SIG,
2160 EVP_PKEY_CTRL_SET_DIGEST_SIZE, "digestsize", NULL,
2161 OSSL_MAC_PARAM_SIZE, OSSL_PARAM_UNSIGNED_INTEGER, NULL },
2167 { SET, -1, -1, EVP_PKEY_OP_DERIVE,
2168 EVP_PKEY_CTRL_TLS_MD, "md", NULL,
2169 OSSL_KDF_PARAM_DIGEST, OSSL_PARAM_UTF8_STRING, fix_md },
2170 { SET, -1, -1, EVP_PKEY_OP_DERIVE,
2171 EVP_PKEY_CTRL_TLS_SECRET, "secret", "hexsecret",
2172 OSSL_KDF_PARAM_SECRET, OSSL_PARAM_OCTET_STRING, NULL },
2173 { SET, -1, -1, EVP_PKEY_OP_DERIVE,
2174 EVP_PKEY_CTRL_TLS_SEED, "seed", "hexseed",
2175 OSSL_KDF_PARAM_SEED, OSSL_PARAM_OCTET_STRING, NULL },
2181 { SET, -1, -1, EVP_PKEY_OP_DERIVE,
2182 EVP_PKEY_CTRL_HKDF_MD, "md", NULL,
2183 OSSL_KDF_PARAM_DIGEST, OSSL_PARAM_UTF8_STRING, fix_md },
2184 { SET, -1, -1, EVP_PKEY_OP_DERIVE,
2185 EVP_PKEY_CTRL_HKDF_SALT, "salt", "hexsalt",
2186 OSSL_KDF_PARAM_SALT, OSSL_PARAM_OCTET_STRING, NULL },
2187 { SET, -1, -1, EVP_PKEY_OP_DERIVE,
2188 EVP_PKEY_CTRL_HKDF_KEY, "key", "hexkey",
2189 OSSL_KDF_PARAM_KEY, OSSL_PARAM_OCTET_STRING, NULL },
2190 { SET, -1, -1, EVP_PKEY_OP_DERIVE,
2191 EVP_PKEY_CTRL_HKDF_INFO, "info", "hexinfo",
2192 OSSL_KDF_PARAM_INFO, OSSL_PARAM_OCTET_STRING, NULL },
2193 { SET, -1, -1, EVP_PKEY_OP_DERIVE,
2194 EVP_PKEY_CTRL_HKDF_MODE, "mode", NULL,
2195 OSSL_KDF_PARAM_MODE, OSSL_PARAM_INTEGER, fix_hkdf_mode },
2201 { SET, -1, -1, EVP_PKEY_OP_DERIVE,
2202 EVP_PKEY_CTRL_PASS, "pass", "hexpass",
2203 OSSL_KDF_PARAM_PASSWORD, OSSL_PARAM_OCTET_STRING, NULL },
2204 { SET, -1, -1, EVP_PKEY_OP_DERIVE,
2205 EVP_PKEY_CTRL_SCRYPT_SALT, "salt", "hexsalt",
2206 OSSL_KDF_PARAM_SALT, OSSL_PARAM_OCTET_STRING, NULL },
2207 { SET, -1, -1, EVP_PKEY_OP_DERIVE,
2208 EVP_PKEY_CTRL_SCRYPT_N, "N", NULL,
2209 OSSL_KDF_PARAM_SCRYPT_N, OSSL_PARAM_UNSIGNED_INTEGER, NULL },
2210 { SET, -1, -1, EVP_PKEY_OP_DERIVE,
2211 EVP_PKEY_CTRL_SCRYPT_R, "r", NULL,
2212 OSSL_KDF_PARAM_SCRYPT_R, OSSL_PARAM_UNSIGNED_INTEGER, NULL },
2213 { SET, -1, -1, EVP_PKEY_OP_DERIVE,
2214 EVP_PKEY_CTRL_SCRYPT_P, "p", NULL,
2215 OSSL_KDF_PARAM_SCRYPT_P, OSSL_PARAM_UNSIGNED_INTEGER, NULL },
2216 { SET, -1, -1, EVP_PKEY_OP_DERIVE,
2217 EVP_PKEY_CTRL_SCRYPT_MAXMEM_BYTES, "maxmem_bytes", NULL,
2218 OSSL_KDF_PARAM_SCRYPT_MAXMEM, OSSL_PARAM_UNSIGNED_INTEGER, NULL },
2220 { SET, -1, -1, EVP_PKEY_OP_KEYGEN | EVP_PKEY_OP_TYPE_CRYPT,
2221 EVP_PKEY_CTRL_CIPHER, NULL, NULL,
2222 OSSL_PKEY_PARAM_CIPHER, OSSL_PARAM_UTF8_STRING, fix_cipher },
2223 { SET, -1, -1, EVP_PKEY_OP_KEYGEN,
2224 EVP_PKEY_CTRL_SET_MAC_KEY, "key", "hexkey",
2225 OSSL_PKEY_PARAM_PRIV_KEY, OSSL_PARAM_OCTET_STRING, NULL },
2227 { SET, -1, -1, EVP_PKEY_OP_TYPE_SIG,
2228 EVP_PKEY_CTRL_MD, NULL, NULL,
2229 OSSL_SIGNATURE_PARAM_DIGEST, OSSL_PARAM_UTF8_STRING, fix_md },
2230 { GET, -1, -1, EVP_PKEY_OP_TYPE_SIG,
2231 EVP_PKEY_CTRL_GET_MD, NULL, NULL,
2232 OSSL_SIGNATURE_PARAM_DIGEST, OSSL_PARAM_UTF8_STRING, fix_md },
2235 static const struct translation_st evp_pkey_translations[] = {
2237 * The following contain no ctrls, they are exclusively here to extract
2238 * key payloads from legacy keys, using OSSL_PARAMs, and rely entirely
2239 * on |fixup_args| to pass the actual data. The |fixup_args| should
2240 * expect to get the EVP_PKEY pointer through |ctx->p2|.
2244 { GET, -1, -1, -1, 0, NULL, NULL,
2245 OSSL_PKEY_PARAM_GROUP_NAME, OSSL_PARAM_UTF8_STRING,
2246 get_payload_group_name },
2247 { GET, -1, -1, -1, 0, NULL, NULL,
2248 OSSL_PKEY_PARAM_PRIV_KEY, OSSL_PARAM_UNSIGNED_INTEGER,
2249 get_payload_private_key },
2250 { GET, -1, -1, -1, 0, NULL, NULL,
2251 OSSL_PKEY_PARAM_PUB_KEY,
2252 0 /* no data type, let get_payload_pub_key() handle that */,
2253 get_payload_public_key },
2256 { GET, -1, -1, -1, 0, NULL, NULL,
2257 OSSL_PKEY_PARAM_FFC_P, OSSL_PARAM_UNSIGNED_INTEGER,
2258 get_dh_dsa_payload_p },
2259 { GET, -1, -1, -1, 0, NULL, NULL,
2260 OSSL_PKEY_PARAM_FFC_G, OSSL_PARAM_UNSIGNED_INTEGER,
2261 get_dh_dsa_payload_g },
2262 { GET, -1, -1, -1, 0, NULL, NULL,
2263 OSSL_PKEY_PARAM_FFC_Q, OSSL_PARAM_UNSIGNED_INTEGER,
2264 get_dh_dsa_payload_q },
2267 { GET, -1, -1, -1, 0, NULL, NULL,
2268 OSSL_PKEY_PARAM_RSA_N, OSSL_PARAM_UNSIGNED_INTEGER,
2269 get_rsa_payload_n },
2270 { GET, -1, -1, -1, 0, NULL, NULL,
2271 OSSL_PKEY_PARAM_RSA_E, OSSL_PARAM_UNSIGNED_INTEGER,
2272 get_rsa_payload_e },
2273 { GET, -1, -1, -1, 0, NULL, NULL,
2274 OSSL_PKEY_PARAM_RSA_D, OSSL_PARAM_UNSIGNED_INTEGER,
2275 get_rsa_payload_d },
2276 { GET, -1, -1, -1, 0, NULL, NULL,
2277 OSSL_PKEY_PARAM_RSA_FACTOR1, OSSL_PARAM_UNSIGNED_INTEGER,
2278 get_rsa_payload_f1 },
2279 { GET, -1, -1, -1, 0, NULL, NULL,
2280 OSSL_PKEY_PARAM_RSA_FACTOR2, OSSL_PARAM_UNSIGNED_INTEGER,
2281 get_rsa_payload_f2 },
2282 { GET, -1, -1, -1, 0, NULL, NULL,
2283 OSSL_PKEY_PARAM_RSA_FACTOR3, OSSL_PARAM_UNSIGNED_INTEGER,
2284 get_rsa_payload_f3 },
2285 { GET, -1, -1, -1, 0, NULL, NULL,
2286 OSSL_PKEY_PARAM_RSA_FACTOR4, OSSL_PARAM_UNSIGNED_INTEGER,
2287 get_rsa_payload_f4 },
2288 { GET, -1, -1, -1, 0, NULL, NULL,
2289 OSSL_PKEY_PARAM_RSA_FACTOR5, OSSL_PARAM_UNSIGNED_INTEGER,
2290 get_rsa_payload_f5 },
2291 { GET, -1, -1, -1, 0, NULL, NULL,
2292 OSSL_PKEY_PARAM_RSA_FACTOR6, OSSL_PARAM_UNSIGNED_INTEGER,
2293 get_rsa_payload_f6 },
2294 { GET, -1, -1, -1, 0, NULL, NULL,
2295 OSSL_PKEY_PARAM_RSA_FACTOR7, OSSL_PARAM_UNSIGNED_INTEGER,
2296 get_rsa_payload_f7 },
2297 { GET, -1, -1, -1, 0, NULL, NULL,
2298 OSSL_PKEY_PARAM_RSA_FACTOR8, OSSL_PARAM_UNSIGNED_INTEGER,
2299 get_rsa_payload_f8 },
2300 { GET, -1, -1, -1, 0, NULL, NULL,
2301 OSSL_PKEY_PARAM_RSA_FACTOR9, OSSL_PARAM_UNSIGNED_INTEGER,
2302 get_rsa_payload_f9 },
2303 { GET, -1, -1, -1, 0, NULL, NULL,
2304 OSSL_PKEY_PARAM_RSA_FACTOR10, OSSL_PARAM_UNSIGNED_INTEGER,
2305 get_rsa_payload_f10 },
2306 { GET, -1, -1, -1, 0, NULL, NULL,
2307 OSSL_PKEY_PARAM_RSA_EXPONENT1, OSSL_PARAM_UNSIGNED_INTEGER,
2308 get_rsa_payload_e1 },
2309 { GET, -1, -1, -1, 0, NULL, NULL,
2310 OSSL_PKEY_PARAM_RSA_EXPONENT2, OSSL_PARAM_UNSIGNED_INTEGER,
2311 get_rsa_payload_e2 },
2312 { GET, -1, -1, -1, 0, NULL, NULL,
2313 OSSL_PKEY_PARAM_RSA_EXPONENT3, OSSL_PARAM_UNSIGNED_INTEGER,
2314 get_rsa_payload_e3 },
2315 { GET, -1, -1, -1, 0, NULL, NULL,
2316 OSSL_PKEY_PARAM_RSA_EXPONENT4, OSSL_PARAM_UNSIGNED_INTEGER,
2317 get_rsa_payload_e4 },
2318 { GET, -1, -1, -1, 0, NULL, NULL,
2319 OSSL_PKEY_PARAM_RSA_EXPONENT5, OSSL_PARAM_UNSIGNED_INTEGER,
2320 get_rsa_payload_e5 },
2321 { GET, -1, -1, -1, 0, NULL, NULL,
2322 OSSL_PKEY_PARAM_RSA_EXPONENT6, OSSL_PARAM_UNSIGNED_INTEGER,
2323 get_rsa_payload_e6 },
2324 { GET, -1, -1, -1, 0, NULL, NULL,
2325 OSSL_PKEY_PARAM_RSA_EXPONENT7, OSSL_PARAM_UNSIGNED_INTEGER,
2326 get_rsa_payload_e7 },
2327 { GET, -1, -1, -1, 0, NULL, NULL,
2328 OSSL_PKEY_PARAM_RSA_EXPONENT8, OSSL_PARAM_UNSIGNED_INTEGER,
2329 get_rsa_payload_e8 },
2330 { GET, -1, -1, -1, 0, NULL, NULL,
2331 OSSL_PKEY_PARAM_RSA_EXPONENT9, OSSL_PARAM_UNSIGNED_INTEGER,
2332 get_rsa_payload_e9 },
2333 { GET, -1, -1, -1, 0, NULL, NULL,
2334 OSSL_PKEY_PARAM_RSA_EXPONENT10, OSSL_PARAM_UNSIGNED_INTEGER,
2335 get_rsa_payload_e10 },
2336 { GET, -1, -1, -1, 0, NULL, NULL,
2337 OSSL_PKEY_PARAM_RSA_COEFFICIENT1, OSSL_PARAM_UNSIGNED_INTEGER,
2338 get_rsa_payload_c1 },
2339 { GET, -1, -1, -1, 0, NULL, NULL,
2340 OSSL_PKEY_PARAM_RSA_COEFFICIENT2, OSSL_PARAM_UNSIGNED_INTEGER,
2341 get_rsa_payload_c2 },
2342 { GET, -1, -1, -1, 0, NULL, NULL,
2343 OSSL_PKEY_PARAM_RSA_COEFFICIENT3, OSSL_PARAM_UNSIGNED_INTEGER,
2344 get_rsa_payload_c3 },
2345 { GET, -1, -1, -1, 0, NULL, NULL,
2346 OSSL_PKEY_PARAM_RSA_COEFFICIENT4, OSSL_PARAM_UNSIGNED_INTEGER,
2347 get_rsa_payload_c4 },
2348 { GET, -1, -1, -1, 0, NULL, NULL,
2349 OSSL_PKEY_PARAM_RSA_COEFFICIENT5, OSSL_PARAM_UNSIGNED_INTEGER,
2350 get_rsa_payload_c5 },
2351 { GET, -1, -1, -1, 0, NULL, NULL,
2352 OSSL_PKEY_PARAM_RSA_COEFFICIENT6, OSSL_PARAM_UNSIGNED_INTEGER,
2353 get_rsa_payload_c6 },
2354 { GET, -1, -1, -1, 0, NULL, NULL,
2355 OSSL_PKEY_PARAM_RSA_COEFFICIENT7, OSSL_PARAM_UNSIGNED_INTEGER,
2356 get_rsa_payload_c7 },
2357 { GET, -1, -1, -1, 0, NULL, NULL,
2358 OSSL_PKEY_PARAM_RSA_COEFFICIENT8, OSSL_PARAM_UNSIGNED_INTEGER,
2359 get_rsa_payload_c8 },
2360 { GET, -1, -1, -1, 0, NULL, NULL,
2361 OSSL_PKEY_PARAM_RSA_COEFFICIENT9, OSSL_PARAM_UNSIGNED_INTEGER,
2362 get_rsa_payload_c9 },
2365 { GET, -1, -1, -1, 0, NULL, NULL,
2366 OSSL_PKEY_PARAM_EC_DECODED_FROM_EXPLICIT_PARAMS, OSSL_PARAM_INTEGER,
2367 get_ec_decoded_from_explicit_params },
2370 static const struct translation_st *
2371 lookup_translation(struct translation_st *tmpl,
2372 const struct translation_st *translations,
2373 size_t translations_num)
2377 for (i = 0; i < translations_num; i++) {
2378 const struct translation_st *item = &translations[i];
2381 * Sanity check the translation table item.
2383 * 1. Either both keytypes are -1, or neither of them are.
2386 if (!ossl_assert((item->keytype1 == -1) == (item->keytype2 == -1)))
2391 * Base search criteria: check that the optype and keytypes match,
2392 * if relevant. All callers must synthesise these bits somehow.
2394 if (item->optype != -1 && (tmpl->optype & item->optype) == 0)
2397 * This expression is stunningly simple thanks to the sanity check
2400 if (item->keytype1 != -1
2401 && tmpl->keytype1 != item->keytype1
2402 && tmpl->keytype2 != item->keytype2)
2406 * Done with the base search criteria, now we check the criteria for
2407 * the individual types of translations:
2408 * ctrl->params, ctrl_str->params, and params->ctrl
2410 if (tmpl->ctrl_num != 0) {
2411 if (tmpl->ctrl_num != item->ctrl_num)
2413 } else if (tmpl->ctrl_str != NULL) {
2414 const char *ctrl_str = NULL;
2415 const char *ctrl_hexstr = NULL;
2418 * Search criteria that originates from a ctrl_str is only used
2419 * for setting, never for getting. Therefore, we only look at
2422 if (item->action_type != NONE
2423 && item->action_type != SET)
2426 * At least one of the ctrl cmd names must be match the ctrl
2427 * cmd name in the template.
2429 if (item->ctrl_str != NULL
2430 && strcasecmp(tmpl->ctrl_str, item->ctrl_str) == 0)
2431 ctrl_str = tmpl->ctrl_str;
2432 else if (item->ctrl_hexstr != NULL
2433 && strcasecmp(tmpl->ctrl_hexstr, item->ctrl_hexstr) == 0)
2434 ctrl_hexstr = tmpl->ctrl_hexstr;
2438 /* Modify the template to signal which string matched */
2439 tmpl->ctrl_str = ctrl_str;
2440 tmpl->ctrl_hexstr = ctrl_hexstr;
2441 } else if (tmpl->param_key != NULL) {
2443 * Search criteria that originates from a OSSL_PARAM setter or
2446 * Ctrls were fundamentally bidirectional, with only the ctrl
2447 * command macro name implying direction (if you're lucky).
2448 * A few ctrl commands were even taking advantage of the
2449 * bidirectional nature, making the direction depend in the
2450 * value of the numeric argument.
2452 * OSSL_PARAM functions are fundamentally different, in that
2453 * setters and getters are separated, so the data direction is
2454 * implied by the function that's used. The same OSSL_PARAM
2455 * key name can therefore be used in both directions. We must
2456 * therefore take the action type into account in this case.
2458 if ((item->action_type != NONE
2459 && tmpl->action_type != item->action_type)
2460 || (item->param_key != NULL
2461 && strcasecmp(tmpl->param_key, item->param_key) != 0))
2473 static const struct translation_st *
2474 lookup_evp_pkey_ctx_translation(struct translation_st *tmpl)
2476 return lookup_translation(tmpl, evp_pkey_ctx_translations,
2477 OSSL_NELEM(evp_pkey_ctx_translations));
2480 static const struct translation_st *
2481 lookup_evp_pkey_translation(struct translation_st *tmpl)
2483 return lookup_translation(tmpl, evp_pkey_translations,
2484 OSSL_NELEM(evp_pkey_translations));
2487 /* This must ONLY be called for provider side operations */
2488 int evp_pkey_ctx_ctrl_to_param(EVP_PKEY_CTX *pctx,
2489 int keytype, int optype,
2490 int cmd, int p1, void *p2)
2492 struct translation_ctx_st ctx = { 0, };
2493 struct translation_st tmpl = { 0, };
2494 const struct translation_st *translation = NULL;
2495 OSSL_PARAM params[2] = { OSSL_PARAM_END, OSSL_PARAM_END };
2497 fixup_args_fn *fixup = default_fixup_args;
2500 keytype = pctx->legacy_keytype;
2501 tmpl.ctrl_num = cmd;
2502 tmpl.keytype1 = tmpl.keytype2 = keytype;
2503 tmpl.optype = optype;
2504 translation = lookup_evp_pkey_ctx_translation(&tmpl);
2506 if (translation == NULL) {
2507 ERR_raise(ERR_LIB_EVP, EVP_R_COMMAND_NOT_SUPPORTED);
2511 if (pctx->pmeth != NULL
2512 && pctx->pmeth->pkey_id != translation->keytype1
2513 && pctx->pmeth->pkey_id != translation->keytype2)
2516 if (translation->fixup_args != NULL)
2517 fixup = translation->fixup_args;
2518 ctx.action_type = translation->action_type;
2523 ctx.params = params;
2525 ret = fixup(PRE_CTRL_TO_PARAMS, translation, &ctx);
2528 switch (ctx.action_type) {
2530 /* fixup_args is expected to make sure this is dead code */
2533 ret = evp_pkey_ctx_get_params_strict(pctx, ctx.params);
2536 ret = evp_pkey_ctx_set_params_strict(pctx, ctx.params);
2542 * In POST, we pass the return value as p1, allowing the fixup_args
2543 * function to affect it by changing its value.
2547 fixup(POST_CTRL_TO_PARAMS, translation, &ctx);
2551 cleanup_translation_ctx(POST_CTRL_TO_PARAMS, translation, &ctx);
2556 /* This must ONLY be called for provider side operations */
2557 int evp_pkey_ctx_ctrl_str_to_param(EVP_PKEY_CTX *pctx,
2558 const char *name, const char *value)
2560 struct translation_ctx_st ctx = { 0, };
2561 struct translation_st tmpl = { 0, };
2562 const struct translation_st *translation = NULL;
2563 OSSL_PARAM params[2] = { OSSL_PARAM_END, OSSL_PARAM_END };
2564 int keytype = pctx->legacy_keytype;
2565 int optype = pctx->operation == 0 ? -1 : pctx->operation;
2567 fixup_args_fn *fixup = default_fixup_args;
2569 tmpl.action_type = SET;
2570 tmpl.keytype1 = tmpl.keytype2 = keytype;
2571 tmpl.optype = optype;
2572 tmpl.ctrl_str = name;
2573 tmpl.ctrl_hexstr = name;
2574 translation = lookup_evp_pkey_ctx_translation(&tmpl);
2576 if (translation != NULL) {
2577 if (translation->fixup_args != NULL)
2578 fixup = translation->fixup_args;
2579 ctx.action_type = translation->action_type;
2580 ctx.ishex = (tmpl.ctrl_hexstr != NULL);
2582 /* String controls really only support setting */
2583 ctx.action_type = SET;
2585 ctx.ctrl_str = name;
2586 ctx.p1 = (int)strlen(value);
2587 ctx.p2 = (char *)value;
2589 ctx.params = params;
2591 ret = fixup(PRE_CTRL_STR_TO_PARAMS, translation, &ctx);
2594 switch (ctx.action_type) {
2596 /* fixup_args is expected to make sure this is dead code */
2600 * this is dead code, but must be present, or some compilers
2605 ret = evp_pkey_ctx_set_params_strict(pctx, ctx.params);
2611 ret = fixup(POST_CTRL_STR_TO_PARAMS, translation, &ctx);
2613 cleanup_translation_ctx(CLEANUP_CTRL_STR_TO_PARAMS, translation, &ctx);
2618 /* This must ONLY be called for legacy operations */
2619 static int evp_pkey_ctx_setget_params_to_ctrl(EVP_PKEY_CTX *pctx,
2620 enum action action_type,
2623 int keytype = pctx->legacy_keytype;
2624 int optype = pctx->operation == 0 ? -1 : pctx->operation;
2626 for (; params != NULL && params->key != NULL; params++) {
2627 struct translation_ctx_st ctx = { 0, };
2628 struct translation_st tmpl = { 0, };
2629 const struct translation_st *translation = NULL;
2630 fixup_args_fn *fixup = default_fixup_args;
2633 tmpl.action_type = action_type;
2634 tmpl.keytype1 = tmpl.keytype2 = keytype;
2635 tmpl.optype = optype;
2636 tmpl.param_key = params->key;
2637 translation = lookup_evp_pkey_ctx_translation(&tmpl);
2639 if (translation != NULL) {
2640 if (translation->fixup_args != NULL)
2641 fixup = translation->fixup_args;
2642 ctx.action_type = translation->action_type;
2645 ctx.params = params;
2647 ret = fixup(PRE_PARAMS_TO_CTRL, translation, &ctx);
2649 if (ret > 0 && action_type != NONE)
2650 ret = EVP_PKEY_CTX_ctrl(pctx, keytype, optype,
2651 ctx.ctrl_cmd, ctx.p1, ctx.p2);
2654 * In POST, we pass the return value as p1, allowing the fixup_args
2655 * function to put it to good use, or maybe affect it.
2659 fixup(POST_PARAMS_TO_CTRL, translation, &ctx);
2663 cleanup_translation_ctx(CLEANUP_PARAMS_TO_CTRL, translation, &ctx);
2671 int evp_pkey_ctx_set_params_to_ctrl(EVP_PKEY_CTX *ctx, const OSSL_PARAM *params)
2673 return evp_pkey_ctx_setget_params_to_ctrl(ctx, SET, (OSSL_PARAM *)params);
2676 int evp_pkey_ctx_get_params_to_ctrl(EVP_PKEY_CTX *ctx, OSSL_PARAM *params)
2678 return evp_pkey_ctx_setget_params_to_ctrl(ctx, GET, params);
2681 /* This must ONLY be called for legacy EVP_PKEYs */
2682 static int evp_pkey_setget_params_to_ctrl(const EVP_PKEY *pkey,
2683 enum action action_type,
2688 for (; params != NULL && params->key != NULL; params++) {
2689 struct translation_ctx_st ctx = { 0, };
2690 struct translation_st tmpl = { 0, };
2691 const struct translation_st *translation = NULL;
2692 fixup_args_fn *fixup = default_fixup_args;
2694 tmpl.action_type = action_type;
2695 tmpl.param_key = params->key;
2696 translation = lookup_evp_pkey_translation(&tmpl);
2698 if (translation != NULL) {
2699 if (translation->fixup_args != NULL)
2700 fixup = translation->fixup_args;
2701 ctx.action_type = translation->action_type;
2703 ctx.p2 = (void *)pkey;
2704 ctx.params = params;
2707 * EVP_PKEY doesn't have any ctrl function, so we rely completely
2708 * on fixup_args to do the whole work. Also, we currently only
2711 if (!ossl_assert(translation != NULL)
2712 || !ossl_assert(translation->action_type == GET)
2713 || !ossl_assert(translation->fixup_args != NULL)) {
2717 ret = fixup(PKEY, translation, &ctx);
2719 cleanup_translation_ctx(PKEY, translation, &ctx);
2724 int evp_pkey_get_params_to_ctrl(const EVP_PKEY *pkey, OSSL_PARAM *params)
2726 return evp_pkey_setget_params_to_ctrl(pkey, GET, params);