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_name(cipher
);
716 static const char *get_md_name(void *md
)
718 return EVP_MD_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 strcpy(ctx
->name_buf
, str_value_map
[i
].ptr
);
1358 ctx
->p2
= ctx
->name_buf
;
1359 ctx
->p1
= strlen(ctx
->p2
);
1362 if ((ret
= default_fixup_args(state
, translation
, ctx
)) <= 0)
1365 if ((ctx
->action_type
== SET
&& state
== PRE_PARAMS_TO_CTRL
)
1366 || (ctx
->action_type
== GET
&& state
== POST_CTRL_TO_PARAMS
)) {
1369 for (i
= 0; i
< OSSL_NELEM(str_value_map
); i
++) {
1370 if (strcmp(ctx
->p2
, str_value_map
[i
].ptr
) == 0)
1373 if (i
== OSSL_NELEM(str_value_map
)) {
1374 ctx
->p1
= atoi(ctx
->p2
);
1375 } else if (state
== POST_CTRL_TO_PARAMS
) {
1377 * EVP_PKEY_CTRL_GET_RSA_PSS_SALTLEN weirdness explained further
1380 *(int *)ctx
->orig_p2
= str_value_map
[i
].id
;
1382 ctx
->p1
= (int)str_value_map
[i
].id
;
1390 /* EVP_PKEY_CTRL_HKDF_MODE */
1391 static int fix_hkdf_mode(enum state state
,
1392 const struct translation_st
*translation
,
1393 struct translation_ctx_st
*ctx
)
1395 static const OSSL_ITEM str_value_map
[] = {
1396 { EVP_KDF_HKDF_MODE_EXTRACT_AND_EXPAND
, "EXTRACT_AND_EXPAND" },
1397 { EVP_KDF_HKDF_MODE_EXTRACT_ONLY
, "EXTRACT_ONLY" },
1398 { EVP_KDF_HKDF_MODE_EXPAND_ONLY
, "EXPAND_ONLY" }
1402 if ((ret
= default_check(state
, translation
, ctx
)) <= 0)
1405 if ((ctx
->action_type
== SET
&& state
== PRE_CTRL_TO_PARAMS
)
1406 || (ctx
->action_type
== GET
&& state
== POST_PARAMS_TO_CTRL
)) {
1409 for (i
= 0; i
< OSSL_NELEM(str_value_map
); i
++) {
1410 if (ctx
->p1
== (int)str_value_map
[i
].id
)
1413 if (i
== OSSL_NELEM(str_value_map
))
1415 ctx
->p2
= str_value_map
[i
].ptr
;
1416 ctx
->p1
= strlen(ctx
->p2
);
1419 if ((ret
= default_fixup_args(state
, translation
, ctx
)) <= 0)
1422 if ((ctx
->action_type
== SET
&& state
== PRE_PARAMS_TO_CTRL
)
1423 || (ctx
->action_type
== GET
&& state
== POST_CTRL_TO_PARAMS
)) {
1426 for (i
= 0; i
< OSSL_NELEM(str_value_map
); i
++) {
1427 if (strcmp(ctx
->p2
, str_value_map
[i
].ptr
) == 0)
1430 if (i
== OSSL_NELEM(str_value_map
))
1432 if (state
== POST_CTRL_TO_PARAMS
)
1433 ret
= str_value_map
[i
].id
;
1435 ctx
->p1
= str_value_map
[i
].id
;
1446 * These all get the data they want, then call default_fixup_args() as
1447 * a post-ctrl GET fixup. They all get NULL ctx, ctrl_cmd, ctrl_str,
1451 /* Pilfering DH, DSA and EC_KEY */
1452 static int get_payload_group_name(enum state state
,
1453 const struct translation_st
*translation
,
1454 struct translation_ctx_st
*ctx
)
1456 EVP_PKEY
*pkey
= ctx
->p2
;
1459 switch (EVP_PKEY_base_id(pkey
)) {
1460 #ifndef OPENSSL_NO_DH
1463 const DH
*dh
= EVP_PKEY_get0_DH(pkey
);
1464 int uid
= DH_get_nid(dh
);
1466 if (uid
!= NID_undef
) {
1467 const DH_NAMED_GROUP
*dh_group
=
1468 ossl_ffc_uid_to_dh_named_group(uid
);
1470 ctx
->p2
= (char *)ossl_ffc_named_group_get_name(dh_group
);
1475 #ifndef OPENSSL_NO_EC
1478 const EC_GROUP
*grp
=
1479 EC_KEY_get0_group(EVP_PKEY_get0_EC_KEY(pkey
));
1480 int nid
= NID_undef
;
1483 nid
= EC_GROUP_get_curve_name(grp
);
1484 if (nid
!= NID_undef
)
1485 ctx
->p2
= (char *)OSSL_EC_curve_nid2name(nid
);
1490 ERR_raise(ERR_LIB_EVP
, EVP_R_UNSUPPORTED_KEY_TYPE
);
1495 * Quietly ignoring unknown groups matches the behaviour on the provider
1498 if (ctx
->p2
== NULL
)
1501 ctx
->p1
= strlen(ctx
->p2
);
1502 return default_fixup_args(state
, translation
, ctx
);
1505 static int get_payload_private_key(enum state state
,
1506 const struct translation_st
*translation
,
1507 struct translation_ctx_st
*ctx
)
1509 EVP_PKEY
*pkey
= ctx
->p2
;
1512 if (ctx
->params
->data_type
!= OSSL_PARAM_UNSIGNED_INTEGER
)
1515 switch (EVP_PKEY_base_id(pkey
)) {
1516 #ifndef OPENSSL_NO_DH
1519 const DH
*dh
= EVP_PKEY_get0_DH(pkey
);
1521 ctx
->p2
= (BIGNUM
*)DH_get0_priv_key(dh
);
1525 #ifndef OPENSSL_NO_EC
1528 const EC_KEY
*ec
= EVP_PKEY_get0_EC_KEY(pkey
);
1530 ctx
->p2
= (BIGNUM
*)EC_KEY_get0_private_key(ec
);
1535 ERR_raise(ERR_LIB_EVP
, EVP_R_UNSUPPORTED_KEY_TYPE
);
1539 return default_fixup_args(state
, translation
, ctx
);
1542 static int get_payload_public_key(enum state state
,
1543 const struct translation_st
*translation
,
1544 struct translation_ctx_st
*ctx
)
1546 EVP_PKEY
*pkey
= ctx
->p2
;
1547 unsigned char *buf
= NULL
;
1551 switch (EVP_PKEY_base_id(pkey
)) {
1552 #ifndef OPENSSL_NO_DH
1554 switch (ctx
->params
->data_type
) {
1555 case OSSL_PARAM_OCTET_STRING
:
1556 ctx
->sz
= ossl_dh_key2buf(EVP_PKEY_get0_DH(pkey
), &buf
, 0, 1);
1559 case OSSL_PARAM_UNSIGNED_INTEGER
:
1560 ctx
->p2
= (void *)DH_get0_pub_key(EVP_PKEY_get0_DH(pkey
));
1567 #ifndef OPENSSL_NO_DSA
1569 if (ctx
->params
->data_type
== OSSL_PARAM_UNSIGNED_INTEGER
) {
1570 ctx
->p2
= (void *)DSA_get0_pub_key(EVP_PKEY_get0_DSA(pkey
));
1575 #ifndef OPENSSL_NO_EC
1577 if (ctx
->params
->data_type
== OSSL_PARAM_OCTET_STRING
) {
1578 const EC_KEY
*eckey
= EVP_PKEY_get0_EC_KEY(pkey
);
1579 BN_CTX
*bnctx
= BN_CTX_new_ex(ossl_ec_key_get_libctx(eckey
));
1580 const EC_GROUP
*ecg
= EC_KEY_get0_group(eckey
);
1581 const EC_POINT
*point
= EC_KEY_get0_public_key(eckey
);
1583 ctx
->sz
= EC_POINT_point2buf(ecg
, point
,
1584 POINT_CONVERSION_COMPRESSED
,
1592 ERR_raise(ERR_LIB_EVP
, EVP_R_UNSUPPORTED_KEY_TYPE
);
1596 ret
= default_fixup_args(state
, translation
, ctx
);
1601 static int get_payload_bn(enum state state
,
1602 const struct translation_st
*translation
,
1603 struct translation_ctx_st
*ctx
, const BIGNUM
*bn
)
1607 if (ctx
->params
->data_type
!= OSSL_PARAM_UNSIGNED_INTEGER
)
1609 ctx
->p2
= (BIGNUM
*)bn
;
1611 return default_fixup_args(state
, translation
, ctx
);
1614 static int get_dh_dsa_payload_p(enum state state
,
1615 const struct translation_st
*translation
,
1616 struct translation_ctx_st
*ctx
)
1618 const BIGNUM
*bn
= NULL
;
1619 EVP_PKEY
*pkey
= ctx
->p2
;
1621 switch (EVP_PKEY_base_id(pkey
)) {
1622 #ifndef OPENSSL_NO_DH
1624 bn
= DH_get0_p(EVP_PKEY_get0_DH(pkey
));
1627 #ifndef OPENSSL_NO_DSA
1629 bn
= DSA_get0_p(EVP_PKEY_get0_DSA(pkey
));
1633 ERR_raise(ERR_LIB_EVP
, EVP_R_UNSUPPORTED_KEY_TYPE
);
1636 return get_payload_bn(state
, translation
, ctx
, bn
);
1639 static int get_dh_dsa_payload_q(enum state state
,
1640 const struct translation_st
*translation
,
1641 struct translation_ctx_st
*ctx
)
1643 const BIGNUM
*bn
= NULL
;
1645 switch (EVP_PKEY_base_id(ctx
->p2
)) {
1646 #ifndef OPENSSL_NO_DH
1648 bn
= DH_get0_q(EVP_PKEY_get0_DH(ctx
->p2
));
1651 #ifndef OPENSSL_NO_DSA
1653 bn
= DSA_get0_q(EVP_PKEY_get0_DSA(ctx
->p2
));
1658 return get_payload_bn(state
, translation
, ctx
, bn
);
1661 static int get_dh_dsa_payload_g(enum state state
,
1662 const struct translation_st
*translation
,
1663 struct translation_ctx_st
*ctx
)
1665 const BIGNUM
*bn
= NULL
;
1667 switch (EVP_PKEY_base_id(ctx
->p2
)) {
1668 #ifndef OPENSSL_NO_DH
1670 bn
= DH_get0_g(EVP_PKEY_get0_DH(ctx
->p2
));
1673 #ifndef OPENSSL_NO_DSA
1675 bn
= DSA_get0_g(EVP_PKEY_get0_DSA(ctx
->p2
));
1680 return get_payload_bn(state
, translation
, ctx
, bn
);
1683 static int get_rsa_payload_n(enum state state
,
1684 const struct translation_st
*translation
,
1685 struct translation_ctx_st
*ctx
)
1687 const BIGNUM
*bn
= NULL
;
1689 if (EVP_PKEY_base_id(ctx
->p2
) != EVP_PKEY_RSA
)
1691 bn
= RSA_get0_n(EVP_PKEY_get0_RSA(ctx
->p2
));
1693 return get_payload_bn(state
, translation
, ctx
, bn
);
1696 static int get_rsa_payload_e(enum state state
,
1697 const struct translation_st
*translation
,
1698 struct translation_ctx_st
*ctx
)
1700 const BIGNUM
*bn
= NULL
;
1702 if (EVP_PKEY_base_id(ctx
->p2
) != EVP_PKEY_RSA
)
1704 bn
= RSA_get0_e(EVP_PKEY_get0_RSA(ctx
->p2
));
1706 return get_payload_bn(state
, translation
, ctx
, bn
);
1709 static int get_rsa_payload_d(enum state state
,
1710 const struct translation_st
*translation
,
1711 struct translation_ctx_st
*ctx
)
1713 const BIGNUM
*bn
= NULL
;
1715 if (EVP_PKEY_base_id(ctx
->p2
) != EVP_PKEY_RSA
)
1717 bn
= RSA_get0_d(EVP_PKEY_get0_RSA(ctx
->p2
));
1719 return get_payload_bn(state
, translation
, ctx
, bn
);
1722 static int get_rsa_payload_factor(enum state state
,
1723 const struct translation_st
*translation
,
1724 struct translation_ctx_st
*ctx
,
1727 const RSA
*r
= EVP_PKEY_get0_RSA(ctx
->p2
);
1728 const BIGNUM
*bn
= NULL
;
1730 switch (factornum
) {
1739 size_t pnum
= RSA_get_multi_prime_extra_count(r
);
1740 const BIGNUM
*factors
[10];
1742 if (factornum
- 2 < pnum
1743 && RSA_get0_multi_prime_factors(r
, factors
))
1744 bn
= factors
[factornum
- 2];
1749 return get_payload_bn(state
, translation
, ctx
, bn
);
1752 static int get_rsa_payload_exponent(enum state state
,
1753 const struct translation_st
*translation
,
1754 struct translation_ctx_st
*ctx
,
1757 const RSA
*r
= EVP_PKEY_get0_RSA(ctx
->p2
);
1758 const BIGNUM
*bn
= NULL
;
1760 switch (exponentnum
) {
1762 bn
= RSA_get0_dmp1(r
);
1765 bn
= RSA_get0_dmq1(r
);
1769 size_t pnum
= RSA_get_multi_prime_extra_count(r
);
1770 const BIGNUM
*exps
[10], *coeffs
[10];
1772 if (exponentnum
- 2 < pnum
1773 && RSA_get0_multi_prime_crt_params(r
, exps
, coeffs
))
1774 bn
= exps
[exponentnum
- 2];
1779 return get_payload_bn(state
, translation
, ctx
, bn
);
1782 static int get_rsa_payload_coefficient(enum state state
,
1783 const struct translation_st
*translation
,
1784 struct translation_ctx_st
*ctx
,
1785 size_t coefficientnum
)
1787 const RSA
*r
= EVP_PKEY_get0_RSA(ctx
->p2
);
1788 const BIGNUM
*bn
= NULL
;
1790 switch (coefficientnum
) {
1792 bn
= RSA_get0_iqmp(r
);
1796 size_t pnum
= RSA_get_multi_prime_extra_count(r
);
1797 const BIGNUM
*exps
[10], *coeffs
[10];
1799 if (coefficientnum
- 1 < pnum
1800 && RSA_get0_multi_prime_crt_params(r
, exps
, coeffs
))
1801 bn
= coeffs
[coefficientnum
- 1];
1806 return get_payload_bn(state
, translation
, ctx
, bn
);
1809 #define IMPL_GET_RSA_PAYLOAD_FACTOR(n) \
1811 get_rsa_payload_f##n(enum state state, \
1812 const struct translation_st *translation, \
1813 struct translation_ctx_st *ctx) \
1815 if (EVP_PKEY_base_id(ctx->p2) != EVP_PKEY_RSA) \
1817 return get_rsa_payload_factor(state, translation, ctx, n - 1); \
1820 #define IMPL_GET_RSA_PAYLOAD_EXPONENT(n) \
1822 get_rsa_payload_e##n(enum state state, \
1823 const struct translation_st *translation, \
1824 struct translation_ctx_st *ctx) \
1826 if (EVP_PKEY_base_id(ctx->p2) != EVP_PKEY_RSA) \
1828 return get_rsa_payload_exponent(state, translation, ctx, \
1832 #define IMPL_GET_RSA_PAYLOAD_COEFFICIENT(n) \
1834 get_rsa_payload_c##n(enum state state, \
1835 const struct translation_st *translation, \
1836 struct translation_ctx_st *ctx) \
1838 if (EVP_PKEY_base_id(ctx->p2) != EVP_PKEY_RSA) \
1840 return get_rsa_payload_coefficient(state, translation, ctx, \
1844 IMPL_GET_RSA_PAYLOAD_FACTOR(1)
1845 IMPL_GET_RSA_PAYLOAD_FACTOR(2)
1846 IMPL_GET_RSA_PAYLOAD_FACTOR(3)
1847 IMPL_GET_RSA_PAYLOAD_FACTOR(4)
1848 IMPL_GET_RSA_PAYLOAD_FACTOR(5)
1849 IMPL_GET_RSA_PAYLOAD_FACTOR(6)
1850 IMPL_GET_RSA_PAYLOAD_FACTOR(7)
1851 IMPL_GET_RSA_PAYLOAD_FACTOR(8)
1852 IMPL_GET_RSA_PAYLOAD_FACTOR(9)
1853 IMPL_GET_RSA_PAYLOAD_FACTOR(10)
1854 IMPL_GET_RSA_PAYLOAD_EXPONENT(1)
1855 IMPL_GET_RSA_PAYLOAD_EXPONENT(2)
1856 IMPL_GET_RSA_PAYLOAD_EXPONENT(3)
1857 IMPL_GET_RSA_PAYLOAD_EXPONENT(4)
1858 IMPL_GET_RSA_PAYLOAD_EXPONENT(5)
1859 IMPL_GET_RSA_PAYLOAD_EXPONENT(6)
1860 IMPL_GET_RSA_PAYLOAD_EXPONENT(7)
1861 IMPL_GET_RSA_PAYLOAD_EXPONENT(8)
1862 IMPL_GET_RSA_PAYLOAD_EXPONENT(9)
1863 IMPL_GET_RSA_PAYLOAD_EXPONENT(10)
1864 IMPL_GET_RSA_PAYLOAD_COEFFICIENT(1)
1865 IMPL_GET_RSA_PAYLOAD_COEFFICIENT(2)
1866 IMPL_GET_RSA_PAYLOAD_COEFFICIENT(3)
1867 IMPL_GET_RSA_PAYLOAD_COEFFICIENT(4)
1868 IMPL_GET_RSA_PAYLOAD_COEFFICIENT(5)
1869 IMPL_GET_RSA_PAYLOAD_COEFFICIENT(6)
1870 IMPL_GET_RSA_PAYLOAD_COEFFICIENT(7)
1871 IMPL_GET_RSA_PAYLOAD_COEFFICIENT(8)
1872 IMPL_GET_RSA_PAYLOAD_COEFFICIENT(9)
1875 * The translation table itself
1876 * ============================
1879 static const struct translation_st evp_pkey_ctx_translations
[] = {
1881 * DistID: we pass it to the backend as an octet string,
1882 * but get it back as a pointer to an octet string.
1884 * Note that the EVP_PKEY_CTRL_GET1_ID_LEN is purely for legacy purposes
1885 * that has no separate counterpart in OSSL_PARAM terms, since we get
1886 * the length of the DistID automatically when getting the DistID itself.
1888 { SET
, -1, -1, EVP_PKEY_OP_TYPE_SIG
,
1889 EVP_PKEY_CTRL_SET1_ID
, "distid", "hexdistid",
1890 OSSL_PKEY_PARAM_DIST_ID
, OSSL_PARAM_OCTET_STRING
, NULL
},
1892 EVP_PKEY_CTRL_GET1_ID
, "distid", "hexdistid",
1893 OSSL_PKEY_PARAM_DIST_ID
, OSSL_PARAM_OCTET_PTR
, NULL
},
1895 EVP_PKEY_CTRL_GET1_ID_LEN
, NULL
, NULL
,
1896 OSSL_PKEY_PARAM_DIST_ID
, OSSL_PARAM_OCTET_PTR
, fix_distid_len
},
1904 * EVP_PKEY_CTRL_DH_KDF_TYPE is used both for setting and getting. The
1905 * fixup function has to handle this...
1907 { NONE
, EVP_PKEY_DHX
, 0, EVP_PKEY_OP_DERIVE
,
1908 EVP_PKEY_CTRL_DH_KDF_TYPE
, NULL
, NULL
,
1909 OSSL_EXCHANGE_PARAM_KDF_TYPE
, OSSL_PARAM_UTF8_STRING
,
1911 { SET
, EVP_PKEY_DHX
, 0, EVP_PKEY_OP_DERIVE
,
1912 EVP_PKEY_CTRL_DH_KDF_MD
, NULL
, NULL
,
1913 OSSL_EXCHANGE_PARAM_KDF_DIGEST
, OSSL_PARAM_UTF8_STRING
, fix_md
},
1914 { GET
, EVP_PKEY_DHX
, 0, EVP_PKEY_OP_DERIVE
,
1915 EVP_PKEY_CTRL_GET_DH_KDF_MD
, NULL
, NULL
,
1916 OSSL_EXCHANGE_PARAM_KDF_DIGEST
, OSSL_PARAM_UTF8_STRING
, fix_md
},
1917 { SET
, EVP_PKEY_DHX
, 0, EVP_PKEY_OP_DERIVE
,
1918 EVP_PKEY_CTRL_DH_KDF_OUTLEN
, NULL
, NULL
,
1919 OSSL_EXCHANGE_PARAM_KDF_OUTLEN
, OSSL_PARAM_UNSIGNED_INTEGER
, NULL
},
1920 { GET
, EVP_PKEY_DHX
, 0, EVP_PKEY_OP_DERIVE
,
1921 EVP_PKEY_CTRL_GET_DH_KDF_OUTLEN
, NULL
, NULL
,
1922 OSSL_EXCHANGE_PARAM_KDF_OUTLEN
, OSSL_PARAM_UNSIGNED_INTEGER
, NULL
},
1923 { SET
, EVP_PKEY_DHX
, 0, EVP_PKEY_OP_DERIVE
,
1924 EVP_PKEY_CTRL_DH_KDF_UKM
, NULL
, NULL
,
1925 OSSL_EXCHANGE_PARAM_KDF_UKM
, OSSL_PARAM_OCTET_STRING
, NULL
},
1926 { GET
, EVP_PKEY_DHX
, 0, EVP_PKEY_OP_DERIVE
,
1927 EVP_PKEY_CTRL_GET_DH_KDF_UKM
, NULL
, NULL
,
1928 OSSL_EXCHANGE_PARAM_KDF_UKM
, OSSL_PARAM_OCTET_PTR
, NULL
},
1929 { SET
, EVP_PKEY_DHX
, 0, EVP_PKEY_OP_DERIVE
,
1930 EVP_PKEY_CTRL_DH_KDF_OID
, NULL
, NULL
,
1931 OSSL_KDF_PARAM_CEK_ALG
, OSSL_PARAM_UTF8_STRING
, fix_oid
},
1932 { GET
, EVP_PKEY_DHX
, 0, EVP_PKEY_OP_DERIVE
,
1933 EVP_PKEY_CTRL_GET_DH_KDF_OID
, NULL
, NULL
,
1934 OSSL_KDF_PARAM_CEK_ALG
, OSSL_PARAM_UTF8_STRING
, fix_oid
},
1936 /* DHX Keygen Parameters that are shared with DH */
1937 { SET
, EVP_PKEY_DHX
, 0, EVP_PKEY_OP_PARAMGEN
,
1938 EVP_PKEY_CTRL_DH_PARAMGEN_TYPE
, "dh_paramgen_type", NULL
,
1939 OSSL_PKEY_PARAM_FFC_TYPE
, OSSL_PARAM_UTF8_STRING
, fix_dh_paramgen_type
},
1940 { SET
, EVP_PKEY_DHX
, 0, EVP_PKEY_OP_PARAMGEN
,
1941 EVP_PKEY_CTRL_DH_PARAMGEN_PRIME_LEN
, "dh_paramgen_prime_len", NULL
,
1942 OSSL_PKEY_PARAM_FFC_PBITS
, OSSL_PARAM_UNSIGNED_INTEGER
, NULL
},
1943 { SET
, EVP_PKEY_DHX
, 0, EVP_PKEY_OP_PARAMGEN
| EVP_PKEY_OP_KEYGEN
,
1944 EVP_PKEY_CTRL_DH_NID
, "dh_param", NULL
,
1945 OSSL_PKEY_PARAM_GROUP_NAME
, OSSL_PARAM_UTF8_STRING
, NULL
},
1946 { SET
, EVP_PKEY_DHX
, 0, EVP_PKEY_OP_PARAMGEN
| EVP_PKEY_OP_KEYGEN
,
1947 EVP_PKEY_CTRL_DH_RFC5114
, "dh_rfc5114", NULL
,
1948 OSSL_PKEY_PARAM_GROUP_NAME
, OSSL_PARAM_UTF8_STRING
, fix_dh_nid5114
},
1950 /* DH Keygen Parameters that are shared with DHX */
1951 { SET
, EVP_PKEY_DH
, 0, EVP_PKEY_OP_PARAMGEN
,
1952 EVP_PKEY_CTRL_DH_PARAMGEN_TYPE
, "dh_paramgen_type", NULL
,
1953 OSSL_PKEY_PARAM_FFC_TYPE
, OSSL_PARAM_UTF8_STRING
, fix_dh_paramgen_type
},
1954 { SET
, EVP_PKEY_DH
, 0, EVP_PKEY_OP_PARAMGEN
,
1955 EVP_PKEY_CTRL_DH_PARAMGEN_PRIME_LEN
, "dh_paramgen_prime_len", NULL
,
1956 OSSL_PKEY_PARAM_FFC_PBITS
, OSSL_PARAM_UNSIGNED_INTEGER
, NULL
},
1957 { SET
, EVP_PKEY_DH
, 0, EVP_PKEY_OP_PARAMGEN
| EVP_PKEY_OP_KEYGEN
,
1958 EVP_PKEY_CTRL_DH_NID
, "dh_param", NULL
,
1959 OSSL_PKEY_PARAM_GROUP_NAME
, OSSL_PARAM_UTF8_STRING
, fix_dh_nid
},
1960 { SET
, EVP_PKEY_DH
, 0, EVP_PKEY_OP_PARAMGEN
| EVP_PKEY_OP_KEYGEN
,
1961 EVP_PKEY_CTRL_DH_RFC5114
, "dh_rfc5114", NULL
,
1962 OSSL_PKEY_PARAM_GROUP_NAME
, OSSL_PARAM_UTF8_STRING
, fix_dh_nid5114
},
1964 /* DH specific Keygen Parameters */
1965 { SET
, EVP_PKEY_DH
, 0, EVP_PKEY_OP_PARAMGEN
,
1966 EVP_PKEY_CTRL_DH_PARAMGEN_GENERATOR
, "dh_paramgen_generator", NULL
,
1967 OSSL_PKEY_PARAM_DH_GENERATOR
, OSSL_PARAM_INTEGER
, NULL
},
1969 /* DHX specific Keygen Parameters */
1970 { SET
, EVP_PKEY_DHX
, 0, EVP_PKEY_OP_PARAMGEN
,
1971 EVP_PKEY_CTRL_DH_PARAMGEN_SUBPRIME_LEN
, "dh_paramgen_subprime_len", NULL
,
1972 OSSL_PKEY_PARAM_FFC_QBITS
, OSSL_PARAM_UNSIGNED_INTEGER
, NULL
},
1974 { SET
, EVP_PKEY_DH
, 0, EVP_PKEY_OP_DERIVE
,
1975 EVP_PKEY_CTRL_DH_PAD
, "dh_pad", NULL
,
1976 OSSL_EXCHANGE_PARAM_PAD
, OSSL_PARAM_UNSIGNED_INTEGER
, NULL
},
1982 { SET
, EVP_PKEY_DSA
, 0, EVP_PKEY_OP_PARAMGEN
,
1983 EVP_PKEY_CTRL_DSA_PARAMGEN_BITS
, "dsa_paramgen_bits", NULL
,
1984 OSSL_PKEY_PARAM_FFC_PBITS
, OSSL_PARAM_UNSIGNED_INTEGER
, NULL
},
1985 { SET
, EVP_PKEY_DSA
, 0, EVP_PKEY_OP_PARAMGEN
,
1986 EVP_PKEY_CTRL_DSA_PARAMGEN_Q_BITS
, "dsa_paramgen_q_bits", NULL
,
1987 OSSL_PKEY_PARAM_FFC_QBITS
, OSSL_PARAM_UNSIGNED_INTEGER
, NULL
},
1988 { SET
, EVP_PKEY_DSA
, 0, EVP_PKEY_OP_PARAMGEN
,
1989 EVP_PKEY_CTRL_DSA_PARAMGEN_MD
, "dsa_paramgen_md", NULL
,
1990 OSSL_PKEY_PARAM_FFC_DIGEST
, OSSL_PARAM_UTF8_STRING
, fix_md
},
1996 { SET
, EVP_PKEY_EC
, 0, EVP_PKEY_OP_PARAMGEN
| EVP_PKEY_OP_KEYGEN
,
1997 EVP_PKEY_CTRL_EC_PARAM_ENC
, "ec_param_enc", NULL
,
1998 OSSL_PKEY_PARAM_EC_ENCODING
, OSSL_PARAM_UTF8_STRING
, fix_ec_param_enc
},
1999 { SET
, EVP_PKEY_EC
, 0, EVP_PKEY_OP_PARAMGEN
| EVP_PKEY_OP_KEYGEN
,
2000 EVP_PKEY_CTRL_EC_PARAMGEN_CURVE_NID
, "ec_paramgen_curve", NULL
,
2001 OSSL_PKEY_PARAM_GROUP_NAME
, OSSL_PARAM_UTF8_STRING
,
2002 fix_ec_paramgen_curve_nid
},
2004 * EVP_PKEY_CTRL_EC_ECDH_COFACTOR and EVP_PKEY_CTRL_EC_KDF_TYPE are used
2005 * both for setting and getting. The fixup function has to handle this...
2007 { NONE
, EVP_PKEY_EC
, 0, EVP_PKEY_OP_DERIVE
,
2008 EVP_PKEY_CTRL_EC_ECDH_COFACTOR
, "ecdh_cofactor_mode", NULL
,
2009 OSSL_EXCHANGE_PARAM_EC_ECDH_COFACTOR_MODE
, OSSL_PARAM_INTEGER
,
2010 fix_ecdh_cofactor
},
2011 { NONE
, EVP_PKEY_EC
, 0, EVP_PKEY_OP_DERIVE
,
2012 EVP_PKEY_CTRL_EC_KDF_TYPE
, NULL
, NULL
,
2013 OSSL_EXCHANGE_PARAM_KDF_TYPE
, OSSL_PARAM_UTF8_STRING
, fix_ec_kdf_type
},
2014 { SET
, EVP_PKEY_EC
, 0, EVP_PKEY_OP_DERIVE
,
2015 EVP_PKEY_CTRL_EC_KDF_MD
, "ecdh_kdf_md", NULL
,
2016 OSSL_EXCHANGE_PARAM_KDF_DIGEST
, OSSL_PARAM_UTF8_STRING
, fix_md
},
2017 { GET
, EVP_PKEY_EC
, 0, EVP_PKEY_OP_DERIVE
,
2018 EVP_PKEY_CTRL_GET_EC_KDF_MD
, NULL
, NULL
,
2019 OSSL_EXCHANGE_PARAM_KDF_DIGEST
, OSSL_PARAM_UTF8_STRING
, fix_md
},
2020 { SET
, EVP_PKEY_EC
, 0, EVP_PKEY_OP_DERIVE
,
2021 EVP_PKEY_CTRL_EC_KDF_OUTLEN
, NULL
, NULL
,
2022 OSSL_EXCHANGE_PARAM_KDF_OUTLEN
, OSSL_PARAM_UNSIGNED_INTEGER
, NULL
},
2023 { GET
, EVP_PKEY_EC
, 0, EVP_PKEY_OP_DERIVE
,
2024 EVP_PKEY_CTRL_GET_EC_KDF_OUTLEN
, NULL
, NULL
,
2025 OSSL_EXCHANGE_PARAM_KDF_OUTLEN
, OSSL_PARAM_UNSIGNED_INTEGER
, NULL
},
2026 { SET
, EVP_PKEY_EC
, 0, EVP_PKEY_OP_DERIVE
,
2027 EVP_PKEY_CTRL_EC_KDF_UKM
, NULL
, NULL
,
2028 OSSL_EXCHANGE_PARAM_KDF_UKM
, OSSL_PARAM_OCTET_STRING
, NULL
},
2029 { GET
, EVP_PKEY_EC
, 0, EVP_PKEY_OP_DERIVE
,
2030 EVP_PKEY_CTRL_GET_EC_KDF_UKM
, NULL
, NULL
,
2031 OSSL_EXCHANGE_PARAM_KDF_UKM
, OSSL_PARAM_OCTET_PTR
, NULL
},
2039 * RSA padding modes are numeric with ctrls, strings with ctrl_strs,
2040 * and can be both with OSSL_PARAM. We standardise on strings here,
2041 * fix_rsa_padding_mode() does the work when the caller has a different
2044 { SET
, EVP_PKEY_RSA
, EVP_PKEY_RSA_PSS
,
2045 EVP_PKEY_OP_TYPE_CRYPT
| EVP_PKEY_OP_TYPE_SIG
,
2046 EVP_PKEY_CTRL_RSA_PADDING
, "rsa_padding_mode", NULL
,
2047 OSSL_PKEY_PARAM_PAD_MODE
, OSSL_PARAM_UTF8_STRING
, fix_rsa_padding_mode
},
2048 { GET
, EVP_PKEY_RSA
, EVP_PKEY_RSA_PSS
,
2049 EVP_PKEY_OP_TYPE_CRYPT
| EVP_PKEY_OP_TYPE_SIG
,
2050 EVP_PKEY_CTRL_GET_RSA_PADDING
, NULL
, NULL
,
2051 OSSL_PKEY_PARAM_PAD_MODE
, OSSL_PARAM_UTF8_STRING
, fix_rsa_padding_mode
},
2053 { SET
, EVP_PKEY_RSA
, EVP_PKEY_RSA_PSS
,
2054 EVP_PKEY_OP_TYPE_CRYPT
| EVP_PKEY_OP_TYPE_SIG
,
2055 EVP_PKEY_CTRL_RSA_MGF1_MD
, "rsa_mgf1_md", NULL
,
2056 OSSL_PKEY_PARAM_MGF1_DIGEST
, OSSL_PARAM_UTF8_STRING
, fix_md
},
2057 { GET
, EVP_PKEY_RSA
, EVP_PKEY_RSA_PSS
,
2058 EVP_PKEY_OP_TYPE_CRYPT
| EVP_PKEY_OP_TYPE_SIG
,
2059 EVP_PKEY_CTRL_GET_RSA_MGF1_MD
, NULL
, NULL
,
2060 OSSL_PKEY_PARAM_MGF1_DIGEST
, OSSL_PARAM_UTF8_STRING
, fix_md
},
2063 * RSA-PSS saltlen is essentially numeric, but certain values can be
2064 * expressed as keywords (strings) with ctrl_str. The corresponding
2065 * OSSL_PARAM allows both forms.
2066 * fix_rsa_pss_saltlen() takes care of the distinction.
2068 { SET
, EVP_PKEY_RSA
, EVP_PKEY_RSA_PSS
, EVP_PKEY_OP_TYPE_SIG
,
2069 EVP_PKEY_CTRL_RSA_PSS_SALTLEN
, "rsa_pss_saltlen", NULL
,
2070 OSSL_PKEY_PARAM_RSA_PSS_SALTLEN
, OSSL_PARAM_UTF8_STRING
,
2071 fix_rsa_pss_saltlen
},
2072 { GET
, EVP_PKEY_RSA
, EVP_PKEY_RSA_PSS
, EVP_PKEY_OP_TYPE_SIG
,
2073 EVP_PKEY_CTRL_GET_RSA_PSS_SALTLEN
, NULL
, NULL
,
2074 OSSL_PKEY_PARAM_RSA_PSS_SALTLEN
, OSSL_PARAM_UTF8_STRING
,
2075 fix_rsa_pss_saltlen
},
2077 { SET
, EVP_PKEY_RSA
, 0, EVP_PKEY_OP_TYPE_CRYPT
,
2078 EVP_PKEY_CTRL_RSA_OAEP_MD
, "rsa_oaep_md", NULL
,
2079 OSSL_ASYM_CIPHER_PARAM_OAEP_DIGEST
, OSSL_PARAM_UTF8_STRING
, fix_md
},
2080 { GET
, EVP_PKEY_RSA
, 0, EVP_PKEY_OP_TYPE_CRYPT
,
2081 EVP_PKEY_CTRL_GET_RSA_OAEP_MD
, NULL
, NULL
,
2082 OSSL_ASYM_CIPHER_PARAM_OAEP_DIGEST
, OSSL_PARAM_UTF8_STRING
, fix_md
},
2084 * The "rsa_oaep_label" ctrl_str expects the value to always be hex.
2085 * This is accomodated by default_fixup_args() above, which mimics that
2086 * expectation for any translation item where |ctrl_str| is NULL and
2087 * |ctrl_hexstr| is non-NULL.
2089 { SET
, EVP_PKEY_RSA
, 0, EVP_PKEY_OP_TYPE_CRYPT
,
2090 EVP_PKEY_CTRL_RSA_OAEP_LABEL
, NULL
, "rsa_oaep_label",
2091 OSSL_ASYM_CIPHER_PARAM_OAEP_LABEL
, OSSL_PARAM_OCTET_STRING
, NULL
},
2092 { GET
, EVP_PKEY_RSA
, 0, EVP_PKEY_OP_TYPE_CRYPT
,
2093 EVP_PKEY_CTRL_GET_RSA_OAEP_LABEL
, NULL
, NULL
,
2094 OSSL_ASYM_CIPHER_PARAM_OAEP_LABEL
, OSSL_PARAM_OCTET_STRING
, NULL
},
2096 { SET
, EVP_PKEY_RSA_PSS
, 0, EVP_PKEY_OP_TYPE_GEN
,
2097 EVP_PKEY_CTRL_MD
, "rsa_pss_keygen_md", NULL
,
2098 OSSL_ALG_PARAM_DIGEST
, OSSL_PARAM_UTF8_STRING
, fix_md
},
2099 { SET
, EVP_PKEY_RSA_PSS
, 0, EVP_PKEY_OP_TYPE_GEN
,
2100 EVP_PKEY_CTRL_RSA_MGF1_MD
, "rsa_pss_keygen_mgf1_md", NULL
,
2101 OSSL_PKEY_PARAM_MGF1_DIGEST
, OSSL_PARAM_UTF8_STRING
, fix_md
},
2102 { SET
, EVP_PKEY_RSA_PSS
, 0, EVP_PKEY_OP_TYPE_GEN
,
2103 EVP_PKEY_CTRL_RSA_PSS_SALTLEN
, "rsa_pss_keygen_saltlen", NULL
,
2104 OSSL_SIGNATURE_PARAM_PSS_SALTLEN
, OSSL_PARAM_INTEGER
, NULL
},
2105 { SET
, EVP_PKEY_RSA
, EVP_PKEY_RSA_PSS
, EVP_PKEY_OP_KEYGEN
,
2106 EVP_PKEY_CTRL_RSA_KEYGEN_BITS
, "rsa_keygen_bits", NULL
,
2107 OSSL_PKEY_PARAM_RSA_BITS
, OSSL_PARAM_UNSIGNED_INTEGER
, NULL
},
2108 { SET
, EVP_PKEY_RSA
, 0, EVP_PKEY_OP_KEYGEN
,
2109 EVP_PKEY_CTRL_RSA_KEYGEN_PUBEXP
, "rsa_keygen_pubexp", NULL
,
2110 OSSL_PKEY_PARAM_RSA_E
, OSSL_PARAM_UNSIGNED_INTEGER
, NULL
},
2111 { SET
, EVP_PKEY_RSA
, 0, EVP_PKEY_OP_KEYGEN
,
2112 EVP_PKEY_CTRL_RSA_KEYGEN_PRIMES
, "rsa_keygen_primes", NULL
,
2113 OSSL_PKEY_PARAM_RSA_PRIMES
, OSSL_PARAM_UNSIGNED_INTEGER
, NULL
},
2119 { SET
, -1, -1, EVP_PKEY_OP_TYPE_SIG
,
2120 EVP_PKEY_CTRL_SET_DIGEST_SIZE
, "digestsize", NULL
,
2121 OSSL_MAC_PARAM_SIZE
, OSSL_PARAM_UNSIGNED_INTEGER
, NULL
},
2127 { SET
, -1, -1, EVP_PKEY_OP_DERIVE
,
2128 EVP_PKEY_CTRL_TLS_MD
, "md", NULL
,
2129 OSSL_KDF_PARAM_DIGEST
, OSSL_PARAM_UTF8_STRING
, fix_md
},
2130 { SET
, -1, -1, EVP_PKEY_OP_DERIVE
,
2131 EVP_PKEY_CTRL_TLS_SECRET
, "secret", "hexsecret",
2132 OSSL_KDF_PARAM_SECRET
, OSSL_PARAM_OCTET_STRING
, NULL
},
2133 { SET
, -1, -1, EVP_PKEY_OP_DERIVE
,
2134 EVP_PKEY_CTRL_TLS_SEED
, "seed", "hexseed",
2135 OSSL_KDF_PARAM_SEED
, OSSL_PARAM_OCTET_STRING
, NULL
},
2141 { SET
, -1, -1, EVP_PKEY_OP_DERIVE
,
2142 EVP_PKEY_CTRL_HKDF_MD
, "md", NULL
,
2143 OSSL_KDF_PARAM_DIGEST
, OSSL_PARAM_UTF8_STRING
, fix_md
},
2144 { SET
, -1, -1, EVP_PKEY_OP_DERIVE
,
2145 EVP_PKEY_CTRL_HKDF_SALT
, "salt", "hexsalt",
2146 OSSL_KDF_PARAM_SALT
, OSSL_PARAM_OCTET_STRING
, NULL
},
2147 { SET
, -1, -1, EVP_PKEY_OP_DERIVE
,
2148 EVP_PKEY_CTRL_HKDF_KEY
, "key", "hexkey",
2149 OSSL_KDF_PARAM_KEY
, OSSL_PARAM_OCTET_STRING
, NULL
},
2150 { SET
, -1, -1, EVP_PKEY_OP_DERIVE
,
2151 EVP_PKEY_CTRL_HKDF_INFO
, "info", "hexinfo",
2152 OSSL_KDF_PARAM_INFO
, OSSL_PARAM_OCTET_STRING
, NULL
},
2153 { SET
, -1, -1, EVP_PKEY_OP_DERIVE
,
2154 EVP_PKEY_CTRL_HKDF_MODE
, "mode", NULL
,
2155 OSSL_KDF_PARAM_MODE
, OSSL_PARAM_INTEGER
, fix_hkdf_mode
},
2161 { SET
, -1, -1, EVP_PKEY_OP_DERIVE
,
2162 EVP_PKEY_CTRL_PASS
, "pass", "hexpass",
2163 OSSL_KDF_PARAM_PASSWORD
, OSSL_PARAM_OCTET_STRING
, NULL
},
2164 { SET
, -1, -1, EVP_PKEY_OP_DERIVE
,
2165 EVP_PKEY_CTRL_SCRYPT_SALT
, "salt", "hexsalt",
2166 OSSL_KDF_PARAM_SALT
, OSSL_PARAM_OCTET_STRING
, NULL
},
2167 { SET
, -1, -1, EVP_PKEY_OP_DERIVE
,
2168 EVP_PKEY_CTRL_SCRYPT_N
, "N", NULL
,
2169 OSSL_KDF_PARAM_SCRYPT_N
, OSSL_PARAM_UNSIGNED_INTEGER
, NULL
},
2170 { SET
, -1, -1, EVP_PKEY_OP_DERIVE
,
2171 EVP_PKEY_CTRL_SCRYPT_R
, "r", NULL
,
2172 OSSL_KDF_PARAM_SCRYPT_R
, OSSL_PARAM_UNSIGNED_INTEGER
, NULL
},
2173 { SET
, -1, -1, EVP_PKEY_OP_DERIVE
,
2174 EVP_PKEY_CTRL_SCRYPT_P
, "p", NULL
,
2175 OSSL_KDF_PARAM_SCRYPT_P
, OSSL_PARAM_UNSIGNED_INTEGER
, NULL
},
2176 { SET
, -1, -1, EVP_PKEY_OP_DERIVE
,
2177 EVP_PKEY_CTRL_SCRYPT_MAXMEM_BYTES
, "maxmem_bytes", NULL
,
2178 OSSL_KDF_PARAM_SCRYPT_MAXMEM
, OSSL_PARAM_UNSIGNED_INTEGER
, NULL
},
2180 { SET
, -1, -1, EVP_PKEY_OP_KEYGEN
| EVP_PKEY_OP_TYPE_CRYPT
,
2181 EVP_PKEY_CTRL_CIPHER
, NULL
, NULL
,
2182 OSSL_PKEY_PARAM_CIPHER
, OSSL_PARAM_UTF8_STRING
, fix_cipher
},
2183 { SET
, -1, -1, EVP_PKEY_OP_KEYGEN
,
2184 EVP_PKEY_CTRL_SET_MAC_KEY
, NULL
, NULL
,
2185 OSSL_PKEY_PARAM_PRIV_KEY
, OSSL_PARAM_OCTET_STRING
, NULL
},
2187 { SET
, -1, -1, EVP_PKEY_OP_TYPE_SIG
,
2188 EVP_PKEY_CTRL_MD
, NULL
, NULL
,
2189 OSSL_SIGNATURE_PARAM_DIGEST
, OSSL_PARAM_UTF8_STRING
, fix_md
},
2190 { GET
, -1, -1, EVP_PKEY_OP_TYPE_SIG
,
2191 EVP_PKEY_CTRL_GET_MD
, NULL
, NULL
,
2192 OSSL_SIGNATURE_PARAM_DIGEST
, OSSL_PARAM_UTF8_STRING
, fix_md
},
2195 static const struct translation_st evp_pkey_translations
[] = {
2197 * The following contain no ctrls, they are exclusively here to extract
2198 * key payloads from legacy keys, using OSSL_PARAMs, and rely entirely
2199 * on |fixup_args| to pass the actual data. The |fixup_args| should
2200 * expect to get the EVP_PKEY pointer through |ctx->p2|.
2204 { GET
, -1, -1, -1, 0, NULL
, NULL
,
2205 OSSL_PKEY_PARAM_GROUP_NAME
, OSSL_PARAM_UTF8_STRING
,
2206 get_payload_group_name
},
2207 { GET
, -1, -1, -1, 0, NULL
, NULL
,
2208 OSSL_PKEY_PARAM_PRIV_KEY
, OSSL_PARAM_UNSIGNED_INTEGER
,
2209 get_payload_private_key
},
2210 { GET
, -1, -1, -1, 0, NULL
, NULL
,
2211 OSSL_PKEY_PARAM_PUB_KEY
,
2212 0 /* no data type, let get_payload_pub_key() handle that */,
2213 get_payload_public_key
},
2216 { GET
, -1, -1, -1, 0, NULL
, NULL
,
2217 OSSL_PKEY_PARAM_FFC_P
, OSSL_PARAM_UNSIGNED_INTEGER
,
2218 get_dh_dsa_payload_p
},
2219 { GET
, -1, -1, -1, 0, NULL
, NULL
,
2220 OSSL_PKEY_PARAM_FFC_G
, OSSL_PARAM_UNSIGNED_INTEGER
,
2221 get_dh_dsa_payload_g
},
2222 { GET
, -1, -1, -1, 0, NULL
, NULL
,
2223 OSSL_PKEY_PARAM_FFC_Q
, OSSL_PARAM_UNSIGNED_INTEGER
,
2224 get_dh_dsa_payload_q
},
2227 { GET
, -1, -1, -1, 0, NULL
, NULL
,
2228 OSSL_PKEY_PARAM_RSA_N
, OSSL_PARAM_UNSIGNED_INTEGER
,
2229 get_rsa_payload_n
},
2230 { GET
, -1, -1, -1, 0, NULL
, NULL
,
2231 OSSL_PKEY_PARAM_RSA_E
, OSSL_PARAM_UNSIGNED_INTEGER
,
2232 get_rsa_payload_e
},
2233 { GET
, -1, -1, -1, 0, NULL
, NULL
,
2234 OSSL_PKEY_PARAM_RSA_D
, OSSL_PARAM_UNSIGNED_INTEGER
,
2235 get_rsa_payload_d
},
2236 { GET
, -1, -1, -1, 0, NULL
, NULL
,
2237 OSSL_PKEY_PARAM_RSA_FACTOR1
, OSSL_PARAM_UNSIGNED_INTEGER
,
2238 get_rsa_payload_f1
},
2239 { GET
, -1, -1, -1, 0, NULL
, NULL
,
2240 OSSL_PKEY_PARAM_RSA_FACTOR2
, OSSL_PARAM_UNSIGNED_INTEGER
,
2241 get_rsa_payload_f2
},
2242 { GET
, -1, -1, -1, 0, NULL
, NULL
,
2243 OSSL_PKEY_PARAM_RSA_FACTOR3
, OSSL_PARAM_UNSIGNED_INTEGER
,
2244 get_rsa_payload_f3
},
2245 { GET
, -1, -1, -1, 0, NULL
, NULL
,
2246 OSSL_PKEY_PARAM_RSA_FACTOR4
, OSSL_PARAM_UNSIGNED_INTEGER
,
2247 get_rsa_payload_f4
},
2248 { GET
, -1, -1, -1, 0, NULL
, NULL
,
2249 OSSL_PKEY_PARAM_RSA_FACTOR5
, OSSL_PARAM_UNSIGNED_INTEGER
,
2250 get_rsa_payload_f5
},
2251 { GET
, -1, -1, -1, 0, NULL
, NULL
,
2252 OSSL_PKEY_PARAM_RSA_FACTOR6
, OSSL_PARAM_UNSIGNED_INTEGER
,
2253 get_rsa_payload_f6
},
2254 { GET
, -1, -1, -1, 0, NULL
, NULL
,
2255 OSSL_PKEY_PARAM_RSA_FACTOR7
, OSSL_PARAM_UNSIGNED_INTEGER
,
2256 get_rsa_payload_f7
},
2257 { GET
, -1, -1, -1, 0, NULL
, NULL
,
2258 OSSL_PKEY_PARAM_RSA_FACTOR8
, OSSL_PARAM_UNSIGNED_INTEGER
,
2259 get_rsa_payload_f8
},
2260 { GET
, -1, -1, -1, 0, NULL
, NULL
,
2261 OSSL_PKEY_PARAM_RSA_FACTOR9
, OSSL_PARAM_UNSIGNED_INTEGER
,
2262 get_rsa_payload_f9
},
2263 { GET
, -1, -1, -1, 0, NULL
, NULL
,
2264 OSSL_PKEY_PARAM_RSA_FACTOR10
, OSSL_PARAM_UNSIGNED_INTEGER
,
2265 get_rsa_payload_f10
},
2266 { GET
, -1, -1, -1, 0, NULL
, NULL
,
2267 OSSL_PKEY_PARAM_RSA_EXPONENT1
, OSSL_PARAM_UNSIGNED_INTEGER
,
2268 get_rsa_payload_e1
},
2269 { GET
, -1, -1, -1, 0, NULL
, NULL
,
2270 OSSL_PKEY_PARAM_RSA_EXPONENT2
, OSSL_PARAM_UNSIGNED_INTEGER
,
2271 get_rsa_payload_e2
},
2272 { GET
, -1, -1, -1, 0, NULL
, NULL
,
2273 OSSL_PKEY_PARAM_RSA_EXPONENT3
, OSSL_PARAM_UNSIGNED_INTEGER
,
2274 get_rsa_payload_e3
},
2275 { GET
, -1, -1, -1, 0, NULL
, NULL
,
2276 OSSL_PKEY_PARAM_RSA_EXPONENT4
, OSSL_PARAM_UNSIGNED_INTEGER
,
2277 get_rsa_payload_e4
},
2278 { GET
, -1, -1, -1, 0, NULL
, NULL
,
2279 OSSL_PKEY_PARAM_RSA_EXPONENT5
, OSSL_PARAM_UNSIGNED_INTEGER
,
2280 get_rsa_payload_e5
},
2281 { GET
, -1, -1, -1, 0, NULL
, NULL
,
2282 OSSL_PKEY_PARAM_RSA_EXPONENT6
, OSSL_PARAM_UNSIGNED_INTEGER
,
2283 get_rsa_payload_e6
},
2284 { GET
, -1, -1, -1, 0, NULL
, NULL
,
2285 OSSL_PKEY_PARAM_RSA_EXPONENT7
, OSSL_PARAM_UNSIGNED_INTEGER
,
2286 get_rsa_payload_e7
},
2287 { GET
, -1, -1, -1, 0, NULL
, NULL
,
2288 OSSL_PKEY_PARAM_RSA_EXPONENT8
, OSSL_PARAM_UNSIGNED_INTEGER
,
2289 get_rsa_payload_e8
},
2290 { GET
, -1, -1, -1, 0, NULL
, NULL
,
2291 OSSL_PKEY_PARAM_RSA_EXPONENT9
, OSSL_PARAM_UNSIGNED_INTEGER
,
2292 get_rsa_payload_e9
},
2293 { GET
, -1, -1, -1, 0, NULL
, NULL
,
2294 OSSL_PKEY_PARAM_RSA_EXPONENT10
, OSSL_PARAM_UNSIGNED_INTEGER
,
2295 get_rsa_payload_e10
},
2296 { GET
, -1, -1, -1, 0, NULL
, NULL
,
2297 OSSL_PKEY_PARAM_RSA_COEFFICIENT1
, OSSL_PARAM_UNSIGNED_INTEGER
,
2298 get_rsa_payload_c1
},
2299 { GET
, -1, -1, -1, 0, NULL
, NULL
,
2300 OSSL_PKEY_PARAM_RSA_COEFFICIENT2
, OSSL_PARAM_UNSIGNED_INTEGER
,
2301 get_rsa_payload_c2
},
2302 { GET
, -1, -1, -1, 0, NULL
, NULL
,
2303 OSSL_PKEY_PARAM_RSA_COEFFICIENT3
, OSSL_PARAM_UNSIGNED_INTEGER
,
2304 get_rsa_payload_c3
},
2305 { GET
, -1, -1, -1, 0, NULL
, NULL
,
2306 OSSL_PKEY_PARAM_RSA_COEFFICIENT4
, OSSL_PARAM_UNSIGNED_INTEGER
,
2307 get_rsa_payload_c4
},
2308 { GET
, -1, -1, -1, 0, NULL
, NULL
,
2309 OSSL_PKEY_PARAM_RSA_COEFFICIENT5
, OSSL_PARAM_UNSIGNED_INTEGER
,
2310 get_rsa_payload_c5
},
2311 { GET
, -1, -1, -1, 0, NULL
, NULL
,
2312 OSSL_PKEY_PARAM_RSA_COEFFICIENT6
, OSSL_PARAM_UNSIGNED_INTEGER
,
2313 get_rsa_payload_c6
},
2314 { GET
, -1, -1, -1, 0, NULL
, NULL
,
2315 OSSL_PKEY_PARAM_RSA_COEFFICIENT7
, OSSL_PARAM_UNSIGNED_INTEGER
,
2316 get_rsa_payload_c7
},
2317 { GET
, -1, -1, -1, 0, NULL
, NULL
,
2318 OSSL_PKEY_PARAM_RSA_COEFFICIENT8
, OSSL_PARAM_UNSIGNED_INTEGER
,
2319 get_rsa_payload_c8
},
2320 { GET
, -1, -1, -1, 0, NULL
, NULL
,
2321 OSSL_PKEY_PARAM_RSA_COEFFICIENT9
, OSSL_PARAM_UNSIGNED_INTEGER
,
2322 get_rsa_payload_c9
},
2325 static const struct translation_st
*
2326 lookup_translation(struct translation_st
*tmpl
,
2327 const struct translation_st
*translations
,
2328 size_t translations_num
)
2332 for (i
= 0; i
< translations_num
; i
++) {
2333 const struct translation_st
*item
= &translations
[i
];
2336 * Sanity check the translation table item.
2338 * 1. Either both keytypes are -1, or neither of them are.
2341 if (!ossl_assert((item
->keytype1
== -1) == (item
->keytype2
== -1)))
2346 * Base search criteria: check that the optype and keytypes match,
2347 * if relevant. All callers must synthesise these bits somehow.
2349 if (item
->optype
!= -1 && (tmpl
->optype
& item
->optype
) == 0)
2352 * This expression is stunningly simple thanks to the sanity check
2355 if (item
->keytype1
!= -1
2356 && tmpl
->keytype1
!= item
->keytype1
2357 && tmpl
->keytype2
!= item
->keytype2
)
2361 * Done with the base search criteria, now we check the criteria for
2362 * the individual types of translations:
2363 * ctrl->params, ctrl_str->params, and params->ctrl
2365 if (tmpl
->ctrl_num
!= 0) {
2366 if (tmpl
->ctrl_num
!= item
->ctrl_num
)
2368 } else if (tmpl
->ctrl_str
!= NULL
) {
2369 const char *ctrl_str
= NULL
;
2370 const char *ctrl_hexstr
= NULL
;
2373 * Search criteria that originates from a ctrl_str is only used
2374 * for setting, never for getting. Therefore, we only look at
2377 if (item
->action_type
!= NONE
2378 && item
->action_type
!= SET
)
2381 * At least one of the ctrl cmd names must be match the ctrl
2382 * cmd name in the template.
2384 if (item
->ctrl_str
!= NULL
2385 && strcasecmp(tmpl
->ctrl_str
, item
->ctrl_str
) == 0)
2386 ctrl_str
= tmpl
->ctrl_str
;
2387 else if (item
->ctrl_hexstr
!= NULL
2388 && strcasecmp(tmpl
->ctrl_hexstr
, item
->ctrl_hexstr
) == 0)
2389 ctrl_hexstr
= tmpl
->ctrl_hexstr
;
2393 /* Modify the template to signal which string matched */
2394 tmpl
->ctrl_str
= ctrl_str
;
2395 tmpl
->ctrl_hexstr
= ctrl_hexstr
;
2396 } else if (tmpl
->param_key
!= NULL
) {
2398 * Search criteria that originates from a OSSL_PARAM setter or
2401 * Ctrls were fundamentally bidirectional, with only the ctrl
2402 * command macro name implying direction (if you're lucky).
2403 * A few ctrl commands were even taking advantage of the
2404 * bidirectional nature, making the direction depend in the
2405 * value of the numeric argument.
2407 * OSSL_PARAM functions are fundamentally different, in that
2408 * setters and getters are separated, so the data direction is
2409 * implied by the function that's used. The same OSSL_PARAM
2410 * key name can therefore be used in both directions. We must
2411 * therefore take the action type into account in this case.
2413 if ((item
->action_type
!= NONE
2414 && tmpl
->action_type
!= item
->action_type
)
2415 || (item
->param_key
!= NULL
2416 && strcasecmp(tmpl
->param_key
, item
->param_key
) != 0))
2428 static const struct translation_st
*
2429 lookup_evp_pkey_ctx_translation(struct translation_st
*tmpl
)
2431 return lookup_translation(tmpl
, evp_pkey_ctx_translations
,
2432 OSSL_NELEM(evp_pkey_ctx_translations
));
2435 static const struct translation_st
*
2436 lookup_evp_pkey_translation(struct translation_st
*tmpl
)
2438 return lookup_translation(tmpl
, evp_pkey_translations
,
2439 OSSL_NELEM(evp_pkey_translations
));
2442 /* This must ONLY be called for provider side operations */
2443 int evp_pkey_ctx_ctrl_to_param(EVP_PKEY_CTX
*pctx
,
2444 int keytype
, int optype
,
2445 int cmd
, int p1
, void *p2
)
2447 struct translation_ctx_st ctx
= { 0, };
2448 struct translation_st tmpl
= { 0, };
2449 const struct translation_st
*translation
= NULL
;
2450 OSSL_PARAM params
[2] = { OSSL_PARAM_END
, OSSL_PARAM_END
};
2452 fixup_args_fn
*fixup
= default_fixup_args
;
2455 keytype
= pctx
->legacy_keytype
;
2456 tmpl
.ctrl_num
= cmd
;
2457 tmpl
.keytype1
= tmpl
.keytype2
= keytype
;
2458 tmpl
.optype
= optype
;
2459 translation
= lookup_evp_pkey_ctx_translation(&tmpl
);
2461 if (translation
== NULL
) {
2462 ERR_raise(ERR_LIB_EVP
, EVP_R_COMMAND_NOT_SUPPORTED
);
2466 if (pctx
->pmeth
!= NULL
2467 && pctx
->pmeth
->pkey_id
!= translation
->keytype1
2468 && pctx
->pmeth
->pkey_id
!= translation
->keytype2
)
2471 if (translation
->fixup_args
!= NULL
)
2472 fixup
= translation
->fixup_args
;
2473 ctx
.action_type
= translation
->action_type
;
2478 ctx
.params
= params
;
2480 ret
= fixup(PRE_CTRL_TO_PARAMS
, translation
, &ctx
);
2483 switch (ctx
.action_type
) {
2485 /* fixup_args is expected to make sure this is dead code */
2488 ret
= evp_pkey_ctx_get_params_strict(pctx
, ctx
.params
);
2491 ret
= evp_pkey_ctx_set_params_strict(pctx
, ctx
.params
);
2497 * In POST, we pass the return value as p1, allowing the fixup_args
2498 * function to affect it by changing its value.
2502 fixup(POST_CTRL_TO_PARAMS
, translation
, &ctx
);
2506 cleanup_translation_ctx(POST_CTRL_TO_PARAMS
, translation
, &ctx
);
2511 /* This must ONLY be called for provider side operations */
2512 int evp_pkey_ctx_ctrl_str_to_param(EVP_PKEY_CTX
*pctx
,
2513 const char *name
, const char *value
)
2515 struct translation_ctx_st ctx
= { 0, };
2516 struct translation_st tmpl
= { 0, };
2517 const struct translation_st
*translation
= NULL
;
2518 OSSL_PARAM params
[2] = { OSSL_PARAM_END
, OSSL_PARAM_END
};
2519 int keytype
= pctx
->legacy_keytype
;
2520 int optype
= pctx
->operation
== 0 ? -1 : pctx
->operation
;
2522 fixup_args_fn
*fixup
= default_fixup_args
;
2524 tmpl
.action_type
= SET
;
2525 tmpl
.keytype1
= tmpl
.keytype2
= keytype
;
2526 tmpl
.optype
= optype
;
2527 tmpl
.ctrl_str
= name
;
2528 tmpl
.ctrl_hexstr
= name
;
2529 translation
= lookup_evp_pkey_ctx_translation(&tmpl
);
2531 if (translation
!= NULL
) {
2532 if (translation
->fixup_args
!= NULL
)
2533 fixup
= translation
->fixup_args
;
2534 ctx
.action_type
= translation
->action_type
;
2535 ctx
.ishex
= (tmpl
.ctrl_hexstr
!= NULL
);
2537 /* String controls really only support setting */
2538 ctx
.action_type
= SET
;
2540 ctx
.ctrl_str
= name
;
2541 ctx
.p1
= (int)strlen(value
);
2542 ctx
.p2
= (char *)value
;
2544 ctx
.params
= params
;
2546 ret
= fixup(PRE_CTRL_STR_TO_PARAMS
, translation
, &ctx
);
2549 switch (ctx
.action_type
) {
2551 /* fixup_args is expected to make sure this is dead code */
2555 * this is dead code, but must be present, or some compilers
2560 ret
= evp_pkey_ctx_set_params_strict(pctx
, ctx
.params
);
2566 ret
= fixup(POST_CTRL_STR_TO_PARAMS
, translation
, &ctx
);
2568 cleanup_translation_ctx(CLEANUP_CTRL_STR_TO_PARAMS
, translation
, &ctx
);
2573 /* This must ONLY be called for legacy operations */
2574 static int evp_pkey_ctx_setget_params_to_ctrl(EVP_PKEY_CTX
*pctx
,
2575 enum action action_type
,
2578 int keytype
= pctx
->legacy_keytype
;
2579 int optype
= pctx
->operation
== 0 ? -1 : pctx
->operation
;
2581 for (; params
!= NULL
&& params
->key
!= NULL
; params
++) {
2582 struct translation_ctx_st ctx
= { 0, };
2583 struct translation_st tmpl
= { 0, };
2584 const struct translation_st
*translation
= NULL
;
2585 fixup_args_fn
*fixup
= default_fixup_args
;
2588 tmpl
.action_type
= action_type
;
2589 tmpl
.keytype1
= tmpl
.keytype2
= keytype
;
2590 tmpl
.optype
= optype
;
2591 tmpl
.param_key
= params
->key
;
2592 translation
= lookup_evp_pkey_ctx_translation(&tmpl
);
2594 if (translation
!= NULL
) {
2595 if (translation
->fixup_args
!= NULL
)
2596 fixup
= translation
->fixup_args
;
2597 ctx
.action_type
= translation
->action_type
;
2600 ctx
.params
= params
;
2602 ret
= fixup(PRE_PARAMS_TO_CTRL
, translation
, &ctx
);
2604 if (ret
> 0 && action_type
!= NONE
)
2605 ret
= EVP_PKEY_CTX_ctrl(pctx
, keytype
, optype
,
2606 ctx
.ctrl_cmd
, ctx
.p1
, ctx
.p2
);
2609 * In POST, we pass the return value as p1, allowing the fixup_args
2610 * function to put it to good use, or maybe affect it.
2614 fixup(POST_PARAMS_TO_CTRL
, translation
, &ctx
);
2618 cleanup_translation_ctx(CLEANUP_PARAMS_TO_CTRL
, translation
, &ctx
);
2626 int evp_pkey_ctx_set_params_to_ctrl(EVP_PKEY_CTX
*ctx
, const OSSL_PARAM
*params
)
2628 return evp_pkey_ctx_setget_params_to_ctrl(ctx
, SET
, (OSSL_PARAM
*)params
);
2631 int evp_pkey_ctx_get_params_to_ctrl(EVP_PKEY_CTX
*ctx
, OSSL_PARAM
*params
)
2633 return evp_pkey_ctx_setget_params_to_ctrl(ctx
, GET
, params
);
2636 /* This must ONLY be called for legacy EVP_PKEYs */
2637 static int evp_pkey_setget_params_to_ctrl(const EVP_PKEY
*pkey
,
2638 enum action action_type
,
2643 for (; params
!= NULL
&& params
->key
!= NULL
; params
++) {
2644 struct translation_ctx_st ctx
= { 0, };
2645 struct translation_st tmpl
= { 0, };
2646 const struct translation_st
*translation
= NULL
;
2647 fixup_args_fn
*fixup
= default_fixup_args
;
2649 tmpl
.action_type
= action_type
;
2650 tmpl
.param_key
= params
->key
;
2651 translation
= lookup_evp_pkey_translation(&tmpl
);
2653 if (translation
!= NULL
) {
2654 if (translation
->fixup_args
!= NULL
)
2655 fixup
= translation
->fixup_args
;
2656 ctx
.action_type
= translation
->action_type
;
2658 ctx
.p2
= (void *)pkey
;
2659 ctx
.params
= params
;
2662 * EVP_PKEY doesn't have any ctrl function, so we rely completely
2663 * on fixup_args to do the whole work. Also, we currently only
2666 if (!ossl_assert(translation
!= NULL
)
2667 || !ossl_assert(translation
->action_type
== GET
)
2668 || !ossl_assert(translation
->fixup_args
!= NULL
)) {
2672 ret
= fixup(PKEY
, translation
, &ctx
);
2674 cleanup_translation_ctx(PKEY
, translation
, &ctx
);
2679 int evp_pkey_get_params_to_ctrl(const EVP_PKEY
*pkey
, OSSL_PARAM
*params
)
2681 return evp_pkey_setget_params_to_ctrl(pkey
, GET
, params
);