1 /*
2 * Copyright 2021-2024 The OpenSSL Project Authors. All Rights Reserved.
3 *
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
8 */
9
10 /*
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.
15 */
16 #include "internal/deprecated.h"
17
18 #include <string.h>
19
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>
26
27 /* This include gets us all the OSSL_PARAM key string macros */
28 #include <openssl/core_names.h>
29
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"
39
40 struct translation_ctx_st; /* Forwarding */
41 struct translation_st; /* Forwarding */
42
43 /*
44 * The fixup_args functions are called with the following parameters:
45 *
46 * |state| The state we're called in, explained further at the
47 * end of this comment.
48 * |translation| The translation item, to be pilfered for data as
49 * necessary.
50 * |ctx| The translation context, which contains copies of
51 * the following arguments, applicable according to
52 * the caller. All of the attributes in this context
53 * may be freely modified by the fixup_args function.
54 * For cleanup, call cleanup_translation_ctx().
55 *
56 * The |state| tells the fixup_args function something about the caller and
57 * what they may expect:
58 *
59 * PKEY The fixup_args function has been called
60 * from an EVP_PKEY payload getter / setter,
61 * and is fully responsible for getting or
62 * setting the requested data. With this
63 * state, the fixup_args function is expected
64 * to use or modify |*params|, depending on
65 * |action_type|.
66 *
67 * PRE_CTRL_TO_PARAMS The fixup_args function has been called
68 * POST_CTRL_TO_PARAMS from EVP_PKEY_CTX_ctrl(), to help with
69 * translating the ctrl data to an OSSL_PARAM
70 * element or back. The calling sequence is
71 * as follows:
72 *
73 * 1. fixup_args(PRE_CTRL_TO_PARAMS, ...)
74 * 2. EVP_PKEY_CTX_set_params() or
75 * EVP_PKEY_CTX_get_params()
76 * 3. fixup_args(POST_CTRL_TO_PARAMS, ...)
77 *
78 * With the PRE_CTRL_TO_PARAMS state, the
79 * fixup_args function is expected to modify
80 * the passed |*params| in whatever way
81 * necessary, when |action_type == SET|.
82 * With the POST_CTRL_TO_PARAMS state, the
83 * fixup_args function is expected to modify
84 * the passed |p2| in whatever way necessary,
85 * when |action_type == GET|.
86 *
87 * The return value from the fixup_args call
88 * with the POST_CTRL_TO_PARAMS state becomes
89 * the return value back to EVP_PKEY_CTX_ctrl().
90 *
91 * CLEANUP_CTRL_TO_PARAMS The cleanup_args functions has been called
92 * from EVP_PKEY_CTX_ctrl(), to clean up what
93 * the fixup_args function has done, if needed.
94 *
95 *
96 * PRE_CTRL_STR_TO_PARAMS The fixup_args function has been called
97 * POST_CTRL_STR_TO_PARAMS from EVP_PKEY_CTX_ctrl_str(), to help with
98 * translating the ctrl_str data to an
99 * OSSL_PARAM element or back. The calling
100 * sequence is as follows:
101 *
102 * 1. fixup_args(PRE_CTRL_STR_TO_PARAMS, ...)
103 * 2. EVP_PKEY_CTX_set_params() or
104 * EVP_PKEY_CTX_get_params()
105 * 3. fixup_args(POST_CTRL_STR_TO_PARAMS, ...)
106 *
107 * With the PRE_CTRL_STR_TO_PARAMS state,
108 * the fixup_args function is expected to
109 * modify the passed |*params| in whatever
110 * way necessary, when |action_type == SET|.
111 * With the POST_CTRL_STR_TO_PARAMS state,
112 * the fixup_args function is only expected
113 * to return a value.
114 *
115 * CLEANUP_CTRL_STR_TO_PARAMS The cleanup_args functions has been called
116 * from EVP_PKEY_CTX_ctrl_str(), to clean up
117 * what the fixup_args function has done, if
118 * needed.
119 *
120 * PRE_PARAMS_TO_CTRL The fixup_args function has been called
121 * POST_PARAMS_TO_CTRL from EVP_PKEY_CTX_get_params() or
122 * EVP_PKEY_CTX_set_params(), to help with
123 * translating the OSSL_PARAM data to the
124 * corresponding EVP_PKEY_CTX_ctrl() arguments
125 * or the other way around. The calling
126 * sequence is as follows:
127 *
128 * 1. fixup_args(PRE_PARAMS_TO_CTRL, ...)
129 * 2. EVP_PKEY_CTX_ctrl()
130 * 3. fixup_args(POST_PARAMS_TO_CTRL, ...)
131 *
132 * With the PRE_PARAMS_TO_CTRL state, the
133 * fixup_args function is expected to modify
134 * the passed |p1| and |p2| in whatever way
135 * necessary, when |action_type == SET|.
136 * With the POST_PARAMS_TO_CTRL state, the
137 * fixup_args function is expected to
138 * modify the passed |*params| in whatever
139 * way necessary, when |action_type == GET|.
140 *
141 * CLEANUP_PARAMS_TO_CTRL The cleanup_args functions has been called
142 * from EVP_PKEY_CTX_get_params() or
143 * EVP_PKEY_CTX_set_params(), to clean up what
144 * the fixup_args function has done, if needed.
145 */
146 enum state {
147 PKEY,
148 PRE_CTRL_TO_PARAMS, POST_CTRL_TO_PARAMS, CLEANUP_CTRL_TO_PARAMS,
149 PRE_CTRL_STR_TO_PARAMS, POST_CTRL_STR_TO_PARAMS, CLEANUP_CTRL_STR_TO_PARAMS,
150 PRE_PARAMS_TO_CTRL, POST_PARAMS_TO_CTRL, CLEANUP_PARAMS_TO_CTRL
151 };
152 enum action {
153 NONE = 0, GET = 1, SET = 2
154 };
155 typedef int fixup_args_fn(enum state state,
156 const struct translation_st *translation,
157 struct translation_ctx_st *ctx);
158 typedef int cleanup_args_fn(enum state state,
159 const struct translation_st *translation,
160 struct translation_ctx_st *ctx);
161
162 struct translation_ctx_st {
163 /*
164 * The EVP_PKEY_CTX, for calls on that structure, to be pilfered for data
165 * as necessary.
166 */
167 EVP_PKEY_CTX *pctx;
168 /*
169 * The action type (GET or SET). This may be 0 in some cases, and should
170 * be modified by the fixup_args function in the PRE states. It should
171 * otherwise remain untouched once set.
172 */
173 enum action action_type;
174 /*
175 * For ctrl to params translation, the actual ctrl command number used.
176 * For params to ctrl translation, 0.
177 */
178 int ctrl_cmd;
179 /*
180 * For ctrl_str to params translation, the actual ctrl command string
181 * used. In this case, the (string) value is always passed as |p2|.
182 * For params to ctrl translation, this is NULL. Along with it is also
183 * and indicator whether it matched |ctrl_str| or |ctrl_hexstr| in the
184 * translation item.
185 */
186 const char *ctrl_str;
187 int ishex;
188 /* the ctrl-style int argument. */
189 int p1;
190 /* the ctrl-style void* argument. */
191 void *p2;
192 /* a size, for passing back the |p2| size where applicable */
193 size_t sz;
194 /* pointer to the OSSL_PARAM-style params array. */
195 OSSL_PARAM *params;
196
197 /*-
198 * The following are used entirely internally by the fixup_args functions
199 * and should not be touched by the callers, at all.
200 */
201
202 /*
203 * Copy of the ctrl-style void* argument, if the fixup_args function
204 * needs to manipulate |p2| but wants to remember original.
205 */
206 void *orig_p2;
207 /* Diverse types of storage for the needy. */
208 char name_buf[OSSL_MAX_NAME_SIZE];
209 void *allocated_buf;
210 void *bufp;
211 size_t buflen;
212 };
213
214 struct translation_st {
215 /*-
216 * What this table item does.
217 *
218 * If the item has this set to 0, it means that both GET and SET are
219 * supported, and |fixup_args| will determine which it is. This is to
220 * support translations of ctrls where the action type depends on the
221 * value of |p1| or |p2| (ctrls are really bi-directional, but are
222 * seldom used that way).
223 *
224 * This can be also used in the lookup template when it looks up by
225 * OSSL_PARAM key, to indicate if a setter or a getter called.
226 */
227 enum action action_type;
228
229 /*-
230 * Conditions, for params->ctrl translations.
231 *
232 * In table item, |keytype1| and |keytype2| can be set to -1 to indicate
233 * that this item supports all key types (or rather, that |fixup_args|
234 * will check and return an error if it's not supported).
235 * Any of these may be set to 0 to indicate that they are unset.
236 */
237 int keytype1; /* The EVP_PKEY_XXX type, i.e. NIDs. #legacy */
238 int keytype2; /* Another EVP_PKEY_XXX type, used for aliases */
239 int optype; /* The operation type */
240
241 /*
242 * Lookup and translation attributes
243 *
244 * |ctrl_num|, |ctrl_str|, |ctrl_hexstr| and |param_key| are lookup
245 * attributes.
246 *
247 * |ctrl_num| may be 0 or that |param_key| may be NULL in the table item,
248 * but not at the same time. If they are, they are simply not used for
249 * lookup.
250 * When |ctrl_num| == 0, no ctrl will be called. Likewise, when
251 * |param_key| == NULL, no OSSL_PARAM setter/getter will be called.
252 * In that case the treatment of the translation item relies entirely on
253 * |fixup_args|, which is then assumed to have side effects.
254 *
255 * As a special case, it's possible to set |ctrl_hexstr| and assign NULL
256 * to |ctrl_str|. That will signal to default_fixup_args() that the
257 * value must always be interpreted as hex.
258 */
259 int ctrl_num; /* EVP_PKEY_CTRL_xxx */
260 const char *ctrl_str; /* The corresponding ctrl string */
261 const char *ctrl_hexstr; /* The alternative "hex{str}" ctrl string */
262 const char *param_key; /* The corresponding OSSL_PARAM key */
263 /*
264 * The appropriate OSSL_PARAM data type. This may be 0 to indicate that
265 * this OSSL_PARAM may have more than one data type, depending on input
266 * material. In this case, |fixup_args| is expected to check and handle
267 * it.
268 */
269 unsigned int param_data_type;
270
271 /*
272 * Fixer functions
273 *
274 * |fixup_args| is always called before (for SET) or after (for GET)
275 * the actual ctrl / OSSL_PARAM function.
276 */
277 fixup_args_fn *fixup_args;
278 };
279
280 /*-
281 * Fixer function implementations
282 * ==============================
283 */
284
285 /*
286 * default_check isn't a fixer per se, but rather a helper function to
287 * perform certain standard checks.
288 */
default_check(enum state state,const struct translation_st * translation,const struct translation_ctx_st * ctx)289 static int default_check(enum state state,
290 const struct translation_st *translation,
291 const struct translation_ctx_st *ctx)
292 {
293 switch (state) {
294 default:
295 break;
296 case PRE_CTRL_TO_PARAMS:
297 if (!ossl_assert(translation != NULL)) {
298 ERR_raise(ERR_LIB_EVP, EVP_R_COMMAND_NOT_SUPPORTED);
299 return -2;
300 }
301 if (!ossl_assert(translation->param_key != 0)
302 || !ossl_assert(translation->param_data_type != 0)) {
303 ERR_raise(ERR_LIB_EVP, ERR_R_INTERNAL_ERROR);
304 return -1;
305 }
306 break;
307 case PRE_CTRL_STR_TO_PARAMS:
308 /*
309 * For ctrl_str to params translation, we allow direct use of
310 * OSSL_PARAM keys as ctrl_str keys. Therefore, it's possible that
311 * we end up with |translation == NULL|, which is fine. The fixup
312 * function will have to deal with it carefully.
313 */
314 if (translation != NULL) {
315 if (!ossl_assert(translation->action_type != GET)) {
316 ERR_raise(ERR_LIB_EVP, EVP_R_COMMAND_NOT_SUPPORTED);
317 return -2;
318 }
319 if (!ossl_assert(translation->param_key != NULL)
320 || !ossl_assert(translation->param_data_type != 0)) {
321 ERR_raise(ERR_LIB_EVP, ERR_R_INTERNAL_ERROR);
322 return 0;
323 }
324 }
325 break;
326 case PRE_PARAMS_TO_CTRL:
327 case POST_PARAMS_TO_CTRL:
328 if (!ossl_assert(translation != NULL)) {
329 ERR_raise(ERR_LIB_EVP, EVP_R_COMMAND_NOT_SUPPORTED);
330 return -2;
331 }
332 if (!ossl_assert(translation->ctrl_num != 0)
333 || !ossl_assert(translation->param_data_type != 0)) {
334 ERR_raise(ERR_LIB_EVP, ERR_R_INTERNAL_ERROR);
335 return -1;
336 }
337 }
338
339 /* Nothing else to check */
340 return 1;
341 }
342
343 /*-
344 * default_fixup_args fixes up all sorts of arguments, governed by the
345 * diverse attributes in the translation item. It covers all "standard"
346 * base ctrl functionality, meaning it can handle basic conversion of
347 * data between p1+p2 (SET) or return value+p2 (GET) as long as the values
348 * don't have extra semantics (such as NIDs, OIDs, that sort of stuff).
349 * Extra semantics must be handled via specific fixup_args functions.
350 *
351 * The following states and action type combinations have standard handling
352 * done in this function:
353 *
354 * PRE_CTRL_TO_PARAMS, 0 - ERROR. action type must be
355 * determined by a fixup function.
356 * PRE_CTRL_TO_PARAMS, SET | GET - |p1| and |p2| are converted to an
357 * OSSL_PARAM according to the data
358 * type given in |translattion|.
359 * For OSSL_PARAM_UNSIGNED_INTEGER,
360 * a BIGNUM passed as |p2| is accepted.
361 * POST_CTRL_TO_PARAMS, GET - If the OSSL_PARAM data type is a
362 * STRING or PTR type, |p1| is set
363 * to the OSSL_PARAM return size, and
364 * |p2| is set to the string.
365 * PRE_CTRL_STR_TO_PARAMS, !SET - ERROR. That combination is not
366 * supported.
367 * PRE_CTRL_STR_TO_PARAMS, SET - |p2| is taken as a string, and is
368 * converted to an OSSL_PARAM in a
369 * standard manner, guided by the
370 * param key and data type from
371 * |translation|.
372 * PRE_PARAMS_TO_CTRL, SET - the OSSL_PARAM is converted to
373 * |p1| and |p2| according to the
374 * data type given in |translation|
375 * For OSSL_PARAM_UNSIGNED_INTEGER,
376 * if |p2| is non-NULL, then |*p2|
377 * is assigned a BIGNUM, otherwise
378 * |p1| is assigned an unsigned int.
379 * POST_PARAMS_TO_CTRL, GET - |p1| and |p2| are converted to
380 * an OSSL_PARAM, in the same manner
381 * as for the combination of
382 * PRE_CTRL_TO_PARAMS, SET.
383 */
default_fixup_args(enum state state,const struct translation_st * translation,struct translation_ctx_st * ctx)384 static int default_fixup_args(enum state state,
385 const struct translation_st *translation,
386 struct translation_ctx_st *ctx)
387 {
388 int ret;
389
390 if ((ret = default_check(state, translation, ctx)) <= 0)
391 return ret;
392
393 switch (state) {
394 default:
395 /* For states this function should never have been called with */
396 ERR_raise_data(ERR_LIB_EVP, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED,
397 "[action:%d, state:%d]", ctx->action_type, state);
398 return 0;
399
400 /*
401 * PRE_CTRL_TO_PARAMS and POST_CTRL_TO_PARAMS handle ctrl to params
402 * translations. PRE_CTRL_TO_PARAMS is responsible for preparing
403 * |*params|, and POST_CTRL_TO_PARAMS is responsible for bringing the
404 * result back to |*p2| and the return value.
405 */
406 case PRE_CTRL_TO_PARAMS:
407 /* This is ctrl to params translation, so we need an OSSL_PARAM key */
408 if (ctx->action_type == NONE) {
409 /*
410 * No action type is an error here. That's a case for a
411 * special fixup function.
412 */
413 ERR_raise_data(ERR_LIB_EVP, ERR_R_UNSUPPORTED,
414 "[action:%d, state:%d]", ctx->action_type, state);
415 return 0;
416 }
417
418 if (translation->optype != 0) {
419 if ((EVP_PKEY_CTX_IS_SIGNATURE_OP(ctx->pctx)
420 && ctx->pctx->op.sig.algctx == NULL)
421 || (EVP_PKEY_CTX_IS_DERIVE_OP(ctx->pctx)
422 && ctx->pctx->op.kex.algctx == NULL)
423 || (EVP_PKEY_CTX_IS_ASYM_CIPHER_OP(ctx->pctx)
424 && ctx->pctx->op.ciph.algctx == NULL)
425 || (EVP_PKEY_CTX_IS_KEM_OP(ctx->pctx)
426 && ctx->pctx->op.encap.algctx == NULL)
427 /*
428 * The following may be unnecessary, but we have them
429 * for good measure...
430 */
431 || (EVP_PKEY_CTX_IS_GEN_OP(ctx->pctx)
432 && ctx->pctx->op.keymgmt.genctx == NULL)
433 || (EVP_PKEY_CTX_IS_FROMDATA_OP(ctx->pctx)
434 && ctx->pctx->op.keymgmt.genctx == NULL)) {
435 ERR_raise(ERR_LIB_EVP, EVP_R_COMMAND_NOT_SUPPORTED);
436 /* Uses the same return values as EVP_PKEY_CTX_ctrl */
437 return -2;
438 }
439 }
440
441 /*
442 * OSSL_PARAM_construct_TYPE() works equally well for both SET and GET.
443 */
444 switch (translation->param_data_type) {
445 case OSSL_PARAM_INTEGER:
446 *ctx->params = OSSL_PARAM_construct_int(translation->param_key,
447 &ctx->p1);
448 break;
449 case OSSL_PARAM_UNSIGNED_INTEGER:
450 /*
451 * BIGNUMs are passed via |p2|. For all ctrl's that just want
452 * to pass a simple integer via |p1|, |p2| is expected to be
453 * NULL.
454 *
455 * Note that this allocates a buffer, which the cleanup function
456 * must deallocate.
457 */
458 if (ctx->p2 != NULL) {
459 if (ctx->action_type == SET) {
460 ctx->buflen = BN_num_bytes(ctx->p2);
461 if ((ctx->allocated_buf
462 = OPENSSL_malloc(ctx->buflen)) == NULL)
463 return 0;
464 if (BN_bn2nativepad(ctx->p2,
465 ctx->allocated_buf, ctx->buflen) < 0) {
466 OPENSSL_free(ctx->allocated_buf);
467 ctx->allocated_buf = NULL;
468 return 0;
469 }
470 *ctx->params =
471 OSSL_PARAM_construct_BN(translation->param_key,
472 ctx->allocated_buf,
473 ctx->buflen);
474 } else {
475 /*
476 * No support for getting a BIGNUM by ctrl, this needs
477 * fixup_args function support.
478 */
479 ERR_raise_data(ERR_LIB_EVP, ERR_R_UNSUPPORTED,
480 "[action:%d, state:%d] trying to get a "
481 "BIGNUM via ctrl call",
482 ctx->action_type, state);
483 return 0;
484 }
485 } else {
486 *ctx->params =
487 OSSL_PARAM_construct_uint(translation->param_key,
488 (unsigned int *)&ctx->p1);
489 }
490 break;
491 case OSSL_PARAM_UTF8_STRING:
492 *ctx->params =
493 OSSL_PARAM_construct_utf8_string(translation->param_key,
494 ctx->p2, (size_t)ctx->p1);
495 break;
496 case OSSL_PARAM_UTF8_PTR:
497 *ctx->params =
498 OSSL_PARAM_construct_utf8_ptr(translation->param_key,
499 ctx->p2, (size_t)ctx->p1);
500 break;
501 case OSSL_PARAM_OCTET_STRING:
502 *ctx->params =
503 OSSL_PARAM_construct_octet_string(translation->param_key,
504 ctx->p2, (size_t)ctx->p1);
505 break;
506 case OSSL_PARAM_OCTET_PTR:
507 *ctx->params =
508 OSSL_PARAM_construct_octet_ptr(translation->param_key,
509 ctx->p2, (size_t)ctx->p1);
510 break;
511 }
512 break;
513 case POST_CTRL_TO_PARAMS:
514 /*
515 * Because EVP_PKEY_CTX_ctrl() returns the length of certain objects
516 * as its return value, we need to ensure that we do it here as well,
517 * for the OSSL_PARAM data types where this makes sense.
518 */
519 if (ctx->action_type == GET) {
520 switch (translation->param_data_type) {
521 case OSSL_PARAM_UTF8_STRING:
522 case OSSL_PARAM_UTF8_PTR:
523 case OSSL_PARAM_OCTET_STRING:
524 case OSSL_PARAM_OCTET_PTR:
525 ctx->p1 = (int)ctx->params[0].return_size;
526 break;
527 }
528 }
529 break;
530
531 /*
532 * PRE_CTRL_STR_TO_PARAMS and POST_CTRL_STR_TO_PARAMS handle ctrl_str to
533 * params translations. PRE_CTRL_TO_PARAMS is responsible for preparing
534 * |*params|, and POST_CTRL_TO_PARAMS currently has nothing to do, since
535 * there's no support for getting data via ctrl_str calls.
536 */
537 case PRE_CTRL_STR_TO_PARAMS:
538 {
539 /* This is ctrl_str to params translation */
540 const char *tmp_ctrl_str = ctx->ctrl_str;
541 const char *orig_ctrl_str = ctx->ctrl_str;
542 const char *orig_value = ctx->p2;
543 const OSSL_PARAM *settable = NULL;
544 int exists = 0;
545
546 /* Only setting is supported here */
547 if (ctx->action_type != SET) {
548 ERR_raise_data(ERR_LIB_EVP, EVP_R_COMMAND_NOT_SUPPORTED,
549 "[action:%d, state:%d] only setting allowed",
550 ctx->action_type, state);
551 return 0;
552 }
553
554 /*
555 * If no translation exists, we simply pass the control string
556 * unmodified.
557 */
558 if (translation != NULL) {
559 tmp_ctrl_str = ctx->ctrl_str = translation->param_key;
560
561 if (ctx->ishex) {
562 strcpy(ctx->name_buf, "hex");
563 if (OPENSSL_strlcat(ctx->name_buf, tmp_ctrl_str,
564 sizeof(ctx->name_buf)) <= 3) {
565 ERR_raise(ERR_LIB_EVP, ERR_R_INTERNAL_ERROR);
566 return -1;
567 }
568 tmp_ctrl_str = ctx->name_buf;
569 }
570 }
571
572 settable = EVP_PKEY_CTX_settable_params(ctx->pctx);
573 if (!OSSL_PARAM_allocate_from_text(ctx->params, settable,
574 tmp_ctrl_str,
575 ctx->p2, strlen(ctx->p2),
576 &exists)) {
577 if (!exists) {
578 ERR_raise_data(ERR_LIB_EVP, EVP_R_COMMAND_NOT_SUPPORTED,
579 "[action:%d, state:%d] name=%s, value=%s",
580 ctx->action_type, state,
581 orig_ctrl_str, orig_value);
582 return -2;
583 }
584 return 0;
585 }
586 ctx->allocated_buf = ctx->params->data;
587 ctx->buflen = ctx->params->data_size;
588 }
589 break;
590 case POST_CTRL_STR_TO_PARAMS:
591 /* Nothing to be done */
592 break;
593
594 /*
595 * PRE_PARAMS_TO_CTRL and POST_PARAMS_TO_CTRL handle params to ctrl
596 * translations. PRE_PARAMS_TO_CTRL is responsible for preparing
597 * |p1| and |p2|, and POST_PARAMS_TO_CTRL is responsible for bringing
598 * the EVP_PKEY_CTX_ctrl() return value (passed as |p1|) and |p2| back
599 * to |*params|.
600 *
601 * PKEY is treated just like POST_PARAMS_TO_CTRL, making it easy
602 * for the related fixup_args functions to just set |p1| and |p2|
603 * appropriately and leave it to this section of code to fix up
604 * |ctx->params| accordingly.
605 */
606 case PKEY:
607 case POST_PARAMS_TO_CTRL:
608 ret = ctx->p1;
609 /* FALLTHRU */
610 case PRE_PARAMS_TO_CTRL:
611 {
612 /* This is params to ctrl translation */
613 if (state == PRE_PARAMS_TO_CTRL && ctx->action_type == SET) {
614 /* For the PRE state, only setting needs some work to be done */
615
616 /* When setting, we populate |p1| and |p2| from |*params| */
617 switch (translation->param_data_type) {
618 case OSSL_PARAM_INTEGER:
619 return OSSL_PARAM_get_int(ctx->params, &ctx->p1);
620 case OSSL_PARAM_UNSIGNED_INTEGER:
621 if (ctx->p2 != NULL) {
622 /* BIGNUM passed down with p2 */
623 if (!OSSL_PARAM_get_BN(ctx->params, ctx->p2))
624 return 0;
625 } else {
626 /* Normal C unsigned int passed down */
627 if (!OSSL_PARAM_get_uint(ctx->params,
628 (unsigned int *)&ctx->p1))
629 return 0;
630 }
631 return 1;
632 case OSSL_PARAM_UTF8_STRING:
633 return OSSL_PARAM_get_utf8_string(ctx->params,
634 ctx->p2, ctx->sz);
635 case OSSL_PARAM_OCTET_STRING:
636 return OSSL_PARAM_get_octet_string(ctx->params,
637 &ctx->p2, ctx->sz,
638 (size_t *)&ctx->p1);
639 case OSSL_PARAM_OCTET_PTR:
640 return OSSL_PARAM_get_octet_ptr(ctx->params,
641 ctx->p2, &ctx->sz);
642 default:
643 ERR_raise_data(ERR_LIB_EVP, ERR_R_UNSUPPORTED,
644 "[action:%d, state:%d] "
645 "unknown OSSL_PARAM data type %d",
646 ctx->action_type, state,
647 translation->param_data_type);
648 return 0;
649 }
650 } else if ((state == POST_PARAMS_TO_CTRL || state == PKEY)
651 && ctx->action_type == GET) {
652 /* For the POST state, only getting needs some work to be done */
653 unsigned int param_data_type = translation->param_data_type;
654 size_t size = (size_t)ctx->p1;
655
656 if (state == PKEY)
657 size = ctx->sz;
658 if (param_data_type == 0) {
659 /* we must have a fixup_args function to work */
660 if (!ossl_assert(translation->fixup_args != NULL)) {
661 ERR_raise(ERR_LIB_EVP, ERR_R_INTERNAL_ERROR);
662 return 0;
663 }
664 param_data_type = ctx->params->data_type;
665 }
666 /* When getting, we populate |*params| from |p1| and |p2| */
667 switch (param_data_type) {
668 case OSSL_PARAM_INTEGER:
669 return OSSL_PARAM_set_int(ctx->params, ctx->p1);
670 case OSSL_PARAM_UNSIGNED_INTEGER:
671 if (ctx->p2 != NULL) {
672 /* BIGNUM passed back */
673 return OSSL_PARAM_set_BN(ctx->params, ctx->p2);
674 } else {
675 /* Normal C unsigned int passed back */
676 return OSSL_PARAM_set_uint(ctx->params,
677 (unsigned int)ctx->p1);
678 }
679 return 0;
680 case OSSL_PARAM_UTF8_STRING:
681 return OSSL_PARAM_set_utf8_string(ctx->params, ctx->p2);
682 case OSSL_PARAM_OCTET_STRING:
683 return OSSL_PARAM_set_octet_string(ctx->params, ctx->p2,
684 size);
685 case OSSL_PARAM_OCTET_PTR:
686 return OSSL_PARAM_set_octet_ptr(ctx->params, *(void **)ctx->p2,
687 size);
688 default:
689 ERR_raise_data(ERR_LIB_EVP, ERR_R_UNSUPPORTED,
690 "[action:%d, state:%d] "
691 "unsupported OSSL_PARAM data type %d",
692 ctx->action_type, state,
693 translation->param_data_type);
694 return 0;
695 }
696 } else if (state == PRE_PARAMS_TO_CTRL && ctx->action_type == GET) {
697 if (translation->param_data_type == OSSL_PARAM_OCTET_PTR)
698 ctx->p2 = &ctx->bufp;
699 }
700 }
701 /* Any other combination is simply pass-through */
702 break;
703 }
704 return ret;
705 }
706
707 static int
cleanup_translation_ctx(enum state state,const struct translation_st * translation,struct translation_ctx_st * ctx)708 cleanup_translation_ctx(enum state state,
709 const struct translation_st *translation,
710 struct translation_ctx_st *ctx)
711 {
712 if (ctx->allocated_buf != NULL)
713 OPENSSL_free(ctx->allocated_buf);
714 ctx->allocated_buf = NULL;
715 return 1;
716 }
717
718 /*
719 * fix_cipher_md fixes up an EVP_CIPHER / EVP_MD to its name on SET,
720 * and cipher / md name to EVP_MD on GET.
721 */
get_cipher_name(void * cipher)722 static const char *get_cipher_name(void *cipher)
723 {
724 return EVP_CIPHER_get0_name(cipher);
725 }
726
get_md_name(void * md)727 static const char *get_md_name(void *md)
728 {
729 return EVP_MD_get0_name(md);
730 }
731
get_cipher_by_name(OSSL_LIB_CTX * libctx,const char * name)732 static const void *get_cipher_by_name(OSSL_LIB_CTX *libctx, const char *name)
733 {
734 return evp_get_cipherbyname_ex(libctx, name);
735 }
736
get_md_by_name(OSSL_LIB_CTX * libctx,const char * name)737 static const void *get_md_by_name(OSSL_LIB_CTX *libctx, const char *name)
738 {
739 return evp_get_digestbyname_ex(libctx, name);
740 }
741
fix_cipher_md(enum state state,const struct translation_st * translation,struct translation_ctx_st * ctx,const char * (* get_name)(void * algo),const void * (* get_algo_by_name)(OSSL_LIB_CTX * libctx,const char * name))742 static int fix_cipher_md(enum state state,
743 const struct translation_st *translation,
744 struct translation_ctx_st *ctx,
745 const char *(*get_name)(void *algo),
746 const void *(*get_algo_by_name)(OSSL_LIB_CTX *libctx,
747 const char *name))
748 {
749 int ret = 1;
750
751 if ((ret = default_check(state, translation, ctx)) <= 0)
752 return ret;
753
754 if (state == PRE_CTRL_TO_PARAMS && ctx->action_type == GET) {
755 /*
756 * |ctx->p2| contains the address to an EVP_CIPHER or EVP_MD pointer
757 * to be filled in. We need to remember it, then make |ctx->p2|
758 * point at a buffer to be filled in with the name, and |ctx->p1|
759 * with its size. default_fixup_args() will take care of the rest
760 * for us.
761 */
762 ctx->orig_p2 = ctx->p2;
763 ctx->p2 = ctx->name_buf;
764 ctx->p1 = sizeof(ctx->name_buf);
765 } else if (state == PRE_CTRL_TO_PARAMS && ctx->action_type == SET) {
766 /*
767 * In different parts of OpenSSL, this ctrl command is used
768 * differently. Some calls pass a NID as p1, others pass an
769 * EVP_CIPHER pointer as p2...
770 */
771 ctx->p2 = (char *)(ctx->p2 == NULL
772 ? OBJ_nid2sn(ctx->p1)
773 : get_name(ctx->p2));
774 ctx->p1 = strlen(ctx->p2);
775 } else if (state == POST_PARAMS_TO_CTRL && ctx->action_type == GET) {
776 ctx->p2 = (ctx->p2 == NULL ? "" : (char *)get_name(ctx->p2));
777 ctx->p1 = strlen(ctx->p2);
778 }
779
780 if ((ret = default_fixup_args(state, translation, ctx)) <= 0)
781 return ret;
782
783 if (state == POST_CTRL_TO_PARAMS && ctx->action_type == GET) {
784 /*
785 * Here's how we reuse |ctx->orig_p2| that was set in the
786 * PRE_CTRL_TO_PARAMS state above.
787 */
788 *(void **)ctx->orig_p2 =
789 (void *)get_algo_by_name(ctx->pctx->libctx, ctx->p2);
790 ctx->p1 = 1;
791 } else if (state == PRE_PARAMS_TO_CTRL && ctx->action_type == SET) {
792 ctx->p2 = (void *)get_algo_by_name(ctx->pctx->libctx, ctx->p2);
793 ctx->p1 = 0;
794 }
795
796 return ret;
797 }
798
fix_cipher(enum state state,const struct translation_st * translation,struct translation_ctx_st * ctx)799 static int fix_cipher(enum state state,
800 const struct translation_st *translation,
801 struct translation_ctx_st *ctx)
802 {
803 return fix_cipher_md(state, translation, ctx,
804 get_cipher_name, get_cipher_by_name);
805 }
806
fix_md(enum state state,const struct translation_st * translation,struct translation_ctx_st * ctx)807 static int fix_md(enum state state,
808 const struct translation_st *translation,
809 struct translation_ctx_st *ctx)
810 {
811 return fix_cipher_md(state, translation, ctx,
812 get_md_name, get_md_by_name);
813 }
814
fix_distid_len(enum state state,const struct translation_st * translation,struct translation_ctx_st * ctx)815 static int fix_distid_len(enum state state,
816 const struct translation_st *translation,
817 struct translation_ctx_st *ctx)
818 {
819 int ret = default_fixup_args(state, translation, ctx);
820
821 if (ret > 0) {
822 ret = 0;
823 if ((state == POST_CTRL_TO_PARAMS
824 || state == POST_CTRL_STR_TO_PARAMS) && ctx->action_type == GET) {
825 *(size_t *)ctx->p2 = ctx->sz;
826 ret = 1;
827 }
828 }
829 return ret;
830 }
831
832 struct kdf_type_map_st {
833 int kdf_type_num;
834 const char *kdf_type_str;
835 };
836
fix_kdf_type(enum state state,const struct translation_st * translation,struct translation_ctx_st * ctx,const struct kdf_type_map_st * kdf_type_map)837 static int fix_kdf_type(enum state state,
838 const struct translation_st *translation,
839 struct translation_ctx_st *ctx,
840 const struct kdf_type_map_st *kdf_type_map)
841 {
842 /*
843 * The EVP_PKEY_CTRL_DH_KDF_TYPE ctrl command is a bit special, in
844 * that it's used both for setting a value, and for getting it, all
845 * depending on the value if |p1|; if |p1| is -2, the backend is
846 * supposed to place the current kdf type in |p2|, and if not, |p1|
847 * is interpreted as the new kdf type.
848 */
849 int ret = 0;
850
851 if ((ret = default_check(state, translation, ctx)) <= 0)
852 return ret;
853
854 if (state == PRE_CTRL_TO_PARAMS) {
855 /*
856 * In |translations|, the initial value for |ctx->action_type| must
857 * be NONE.
858 */
859 if (!ossl_assert(ctx->action_type == NONE))
860 return 0;
861
862 /* The action type depends on the value of *p1 */
863 if (ctx->p1 == -2) {
864 /*
865 * The OSSL_PARAMS getter needs space to store a copy of the kdf
866 * type string. We use |ctx->name_buf|, which has enough space
867 * allocated.
868 *
869 * (this wouldn't be needed if the OSSL_xxx_PARAM_KDF_TYPE
870 * had the data type OSSL_PARAM_UTF8_PTR)
871 */
872 ctx->p2 = ctx->name_buf;
873 ctx->p1 = sizeof(ctx->name_buf);
874 ctx->action_type = GET;
875 } else {
876 ctx->action_type = SET;
877 }
878 }
879
880 if ((ret = default_check(state, translation, ctx)) <= 0)
881 return ret;
882
883 if ((state == PRE_CTRL_TO_PARAMS && ctx->action_type == SET)
884 || (state == POST_PARAMS_TO_CTRL && ctx->action_type == GET)) {
885 ret = -2;
886 /* Convert KDF type numbers to strings */
887 for (; kdf_type_map->kdf_type_str != NULL; kdf_type_map++)
888 if (ctx->p1 == kdf_type_map->kdf_type_num) {
889 ctx->p2 = (char *)kdf_type_map->kdf_type_str;
890 ret = 1;
891 break;
892 }
893 if (ret <= 0)
894 goto end;
895 ctx->p1 = strlen(ctx->p2);
896 }
897
898 if ((ret = default_fixup_args(state, translation, ctx)) <= 0)
899 return ret;
900
901 if ((state == POST_CTRL_TO_PARAMS && ctx->action_type == GET)
902 || (state == PRE_PARAMS_TO_CTRL && ctx->action_type == SET)) {
903 ctx->p1 = ret = -1;
904
905 /* Convert KDF type strings to numbers */
906 for (; kdf_type_map->kdf_type_str != NULL; kdf_type_map++)
907 if (OPENSSL_strcasecmp(ctx->p2, kdf_type_map->kdf_type_str) == 0) {
908 ctx->p1 = kdf_type_map->kdf_type_num;
909 ret = 1;
910 break;
911 }
912 ctx->p2 = NULL;
913 } else if (state == PRE_PARAMS_TO_CTRL && ctx->action_type == GET) {
914 ctx->p1 = -2;
915 }
916 end:
917 return ret;
918 }
919
920 /* EVP_PKEY_CTRL_DH_KDF_TYPE */
fix_dh_kdf_type(enum state state,const struct translation_st * translation,struct translation_ctx_st * ctx)921 static int fix_dh_kdf_type(enum state state,
922 const struct translation_st *translation,
923 struct translation_ctx_st *ctx)
924 {
925 static const struct kdf_type_map_st kdf_type_map[] = {
926 { EVP_PKEY_DH_KDF_NONE, "" },
927 { EVP_PKEY_DH_KDF_X9_42, OSSL_KDF_NAME_X942KDF_ASN1 },
928 { 0, NULL }
929 };
930
931 return fix_kdf_type(state, translation, ctx, kdf_type_map);
932 }
933
934 /* EVP_PKEY_CTRL_EC_KDF_TYPE */
fix_ec_kdf_type(enum state state,const struct translation_st * translation,struct translation_ctx_st * ctx)935 static int fix_ec_kdf_type(enum state state,
936 const struct translation_st *translation,
937 struct translation_ctx_st *ctx)
938 {
939 static const struct kdf_type_map_st kdf_type_map[] = {
940 { EVP_PKEY_ECDH_KDF_NONE, "" },
941 { EVP_PKEY_ECDH_KDF_X9_63, OSSL_KDF_NAME_X963KDF },
942 { 0, NULL }
943 };
944
945 return fix_kdf_type(state, translation, ctx, kdf_type_map);
946 }
947
948 /* EVP_PKEY_CTRL_DH_KDF_OID, EVP_PKEY_CTRL_GET_DH_KDF_OID, ...??? */
fix_oid(enum state state,const struct translation_st * translation,struct translation_ctx_st * ctx)949 static int fix_oid(enum state state,
950 const struct translation_st *translation,
951 struct translation_ctx_st *ctx)
952 {
953 int ret;
954
955 if ((ret = default_check(state, translation, ctx)) <= 0)
956 return ret;
957
958 if ((state == PRE_CTRL_TO_PARAMS && ctx->action_type == SET)
959 || (state == POST_PARAMS_TO_CTRL && ctx->action_type == GET)) {
960 /*
961 * We're translating from ctrl to params and setting the OID, or
962 * we're translating from params to ctrl and getting the OID.
963 * Either way, |ctx->p2| points at an ASN1_OBJECT, and needs to have
964 * that replaced with the corresponding name.
965 * default_fixup_args() will then be able to convert that to the
966 * corresponding OSSL_PARAM.
967 */
968 OBJ_obj2txt(ctx->name_buf, sizeof(ctx->name_buf), ctx->p2, 0);
969 ctx->p2 = (char *)ctx->name_buf;
970 ctx->p1 = 0; /* let default_fixup_args() figure out the length */
971 }
972
973 if ((ret = default_fixup_args(state, translation, ctx)) <= 0)
974 return ret;
975
976 if ((state == PRE_PARAMS_TO_CTRL && ctx->action_type == SET)
977 || (state == POST_CTRL_TO_PARAMS && ctx->action_type == GET)) {
978 /*
979 * We're translating from ctrl to params and setting the OID name,
980 * or we're translating from params to ctrl and getting the OID
981 * name. Either way, default_fixup_args() has placed the OID name
982 * in |ctx->p2|, all we need to do now is to replace that with the
983 * corresponding ASN1_OBJECT.
984 */
985 ctx->p2 = (ASN1_OBJECT *)OBJ_txt2obj(ctx->p2, 0);
986 }
987
988 return ret;
989 }
990
991 /* EVP_PKEY_CTRL_DH_NID */
fix_dh_nid(enum state state,const struct translation_st * translation,struct translation_ctx_st * ctx)992 static int fix_dh_nid(enum state state,
993 const struct translation_st *translation,
994 struct translation_ctx_st *ctx)
995 {
996 int ret;
997
998 if ((ret = default_check(state, translation, ctx)) <= 0)
999 return ret;
1000
1001 /* This is only settable */
1002 if (ctx->action_type != SET)
1003 return 0;
1004
1005 if (state == PRE_CTRL_TO_PARAMS) {
1006 if ((ctx->p2 = (char *)ossl_ffc_named_group_get_name
1007 (ossl_ffc_uid_to_dh_named_group(ctx->p1))) == NULL) {
1008 ERR_raise(ERR_LIB_EVP, EVP_R_INVALID_VALUE);
1009 return 0;
1010 }
1011 ctx->p1 = 0;
1012 }
1013
1014 return default_fixup_args(state, translation, ctx);
1015 }
1016
1017 /* EVP_PKEY_CTRL_DH_RFC5114 */
fix_dh_nid5114(enum state state,const struct translation_st * translation,struct translation_ctx_st * ctx)1018 static int fix_dh_nid5114(enum state state,
1019 const struct translation_st *translation,
1020 struct translation_ctx_st *ctx)
1021 {
1022 int ret;
1023
1024 if ((ret = default_check(state, translation, ctx)) <= 0)
1025 return ret;
1026
1027 /* This is only settable */
1028 if (ctx->action_type != SET)
1029 return 0;
1030
1031 switch (state) {
1032 case PRE_CTRL_TO_PARAMS:
1033 if ((ctx->p2 = (char *)ossl_ffc_named_group_get_name
1034 (ossl_ffc_uid_to_dh_named_group(ctx->p1))) == NULL) {
1035 ERR_raise(ERR_LIB_EVP, EVP_R_INVALID_VALUE);
1036 return 0;
1037 }
1038
1039 ctx->p1 = 0;
1040 break;
1041
1042 case PRE_CTRL_STR_TO_PARAMS:
1043 if (ctx->p2 == NULL)
1044 return 0;
1045 if ((ctx->p2 = (char *)ossl_ffc_named_group_get_name
1046 (ossl_ffc_uid_to_dh_named_group(atoi(ctx->p2)))) == NULL) {
1047 ERR_raise(ERR_LIB_EVP, EVP_R_INVALID_VALUE);
1048 return 0;
1049 }
1050
1051 ctx->p1 = 0;
1052 break;
1053
1054 default:
1055 break;
1056 }
1057
1058 return default_fixup_args(state, translation, ctx);
1059 }
1060
1061 /* EVP_PKEY_CTRL_DH_PARAMGEN_TYPE */
fix_dh_paramgen_type(enum state state,const struct translation_st * translation,struct translation_ctx_st * ctx)1062 static int fix_dh_paramgen_type(enum state state,
1063 const struct translation_st *translation,
1064 struct translation_ctx_st *ctx)
1065 {
1066 int ret;
1067
1068 if ((ret = default_check(state, translation, ctx)) <= 0)
1069 return ret;
1070
1071 /* This is only settable */
1072 if (ctx->action_type != SET)
1073 return 0;
1074
1075 if (state == PRE_CTRL_STR_TO_PARAMS) {
1076 if ((ctx->p2 = (char *)ossl_dh_gen_type_id2name(atoi(ctx->p2)))
1077 == NULL) {
1078 ERR_raise(ERR_LIB_EVP, EVP_R_INVALID_VALUE);
1079 return 0;
1080 }
1081 ctx->p1 = strlen(ctx->p2);
1082 }
1083
1084 return default_fixup_args(state, translation, ctx);
1085 }
1086
1087 /* EVP_PKEY_CTRL_EC_PARAM_ENC */
fix_ec_param_enc(enum state state,const struct translation_st * translation,struct translation_ctx_st * ctx)1088 static int fix_ec_param_enc(enum state state,
1089 const struct translation_st *translation,
1090 struct translation_ctx_st *ctx)
1091 {
1092 int ret;
1093
1094 if ((ret = default_check(state, translation, ctx)) <= 0)
1095 return ret;
1096
1097 /* This is currently only settable */
1098 if (ctx->action_type != SET)
1099 return 0;
1100
1101 if (state == PRE_CTRL_TO_PARAMS) {
1102 switch (ctx->p1) {
1103 case OPENSSL_EC_EXPLICIT_CURVE:
1104 ctx->p2 = OSSL_PKEY_EC_ENCODING_EXPLICIT;
1105 break;
1106 case OPENSSL_EC_NAMED_CURVE:
1107 ctx->p2 = OSSL_PKEY_EC_ENCODING_GROUP;
1108 break;
1109 default:
1110 ret = -2;
1111 goto end;
1112 }
1113 ctx->p1 = 0;
1114 }
1115
1116 if ((ret = default_fixup_args(state, translation, ctx)) <= 0)
1117 return ret;
1118
1119 if (state == PRE_PARAMS_TO_CTRL) {
1120 if (strcmp(ctx->p2, OSSL_PKEY_EC_ENCODING_EXPLICIT) == 0)
1121 ctx->p1 = OPENSSL_EC_EXPLICIT_CURVE;
1122 else if (strcmp(ctx->p2, OSSL_PKEY_EC_ENCODING_GROUP) == 0)
1123 ctx->p1 = OPENSSL_EC_NAMED_CURVE;
1124 else
1125 ctx->p1 = ret = -2;
1126 ctx->p2 = NULL;
1127 }
1128
1129 end:
1130 if (ret == -2)
1131 ERR_raise(ERR_LIB_EVP, EVP_R_COMMAND_NOT_SUPPORTED);
1132 return ret;
1133 }
1134
1135 /* EVP_PKEY_CTRL_EC_PARAMGEN_CURVE_NID */
fix_ec_paramgen_curve_nid(enum state state,const struct translation_st * translation,struct translation_ctx_st * ctx)1136 static int fix_ec_paramgen_curve_nid(enum state state,
1137 const struct translation_st *translation,
1138 struct translation_ctx_st *ctx)
1139 {
1140 char *p2 = NULL;
1141 int ret;
1142
1143 if ((ret = default_check(state, translation, ctx)) <= 0)
1144 return ret;
1145
1146 /* This is currently only settable */
1147 if (ctx->action_type != SET)
1148 return 0;
1149
1150 if (state == PRE_CTRL_TO_PARAMS) {
1151 ctx->p2 = (char *)OBJ_nid2sn(ctx->p1);
1152 ctx->p1 = 0;
1153 } else if (state == PRE_PARAMS_TO_CTRL) {
1154 /*
1155 * We're translating from params to ctrl and setting the curve name.
1156 * The ctrl function needs it to be a NID, but meanwhile, we need
1157 * space to get the curve name from the param. |ctx->name_buf| is
1158 * sufficient for that.
1159 * The double indirection is necessary for default_fixup_args()'s
1160 * call of OSSL_PARAM_get_utf8_string() to be done correctly.
1161 */
1162 p2 = ctx->name_buf;
1163 ctx->p2 = &p2;
1164 ctx->sz = sizeof(ctx->name_buf);
1165 }
1166
1167 if ((ret = default_fixup_args(state, translation, ctx)) <= 0)
1168 return ret;
1169
1170 if (state == PRE_PARAMS_TO_CTRL) {
1171 ctx->p1 = OBJ_sn2nid(p2);
1172 ctx->p2 = NULL;
1173 }
1174
1175 return ret;
1176 }
1177
1178 /* EVP_PKEY_CTRL_EC_ECDH_COFACTOR */
fix_ecdh_cofactor(enum state state,const struct translation_st * translation,struct translation_ctx_st * ctx)1179 static int fix_ecdh_cofactor(enum state state,
1180 const struct translation_st *translation,
1181 struct translation_ctx_st *ctx)
1182 {
1183 /*
1184 * The EVP_PKEY_CTRL_EC_ECDH_COFACTOR ctrl command is a bit special, in
1185 * that it's used both for setting a value, and for getting it, all
1186 * depending on the value if |ctx->p1|; if |ctx->p1| is -2, the backend is
1187 * supposed to place the current cofactor mode in |ctx->p2|, and if not,
1188 * |ctx->p1| is interpreted as the new cofactor mode.
1189 */
1190 int ret = 0;
1191
1192 if (state == PRE_CTRL_TO_PARAMS) {
1193 /*
1194 * The initial value for |ctx->action_type| must be zero.
1195 * evp_pkey_ctrl_to_params() takes it from the translation item.
1196 */
1197 if (!ossl_assert(ctx->action_type == NONE))
1198 return 0;
1199
1200 /* The action type depends on the value of ctx->p1 */
1201 if (ctx->p1 == -2)
1202 ctx->action_type = GET;
1203 else
1204 ctx->action_type = SET;
1205 } else if (state == PRE_CTRL_STR_TO_PARAMS) {
1206 ctx->action_type = SET;
1207 } else if (state == PRE_PARAMS_TO_CTRL) {
1208 /* The initial value for |ctx->action_type| must not be zero. */
1209 if (!ossl_assert(ctx->action_type != NONE))
1210 return 0;
1211 } else if (state == POST_PARAMS_TO_CTRL && ctx->action_type == NONE) {
1212 ctx->action_type = GET;
1213 }
1214
1215 if ((ret = default_check(state, translation, ctx)) <= 0)
1216 return ret;
1217
1218 if (state == PRE_CTRL_TO_PARAMS && ctx->action_type == SET) {
1219 if (ctx->p1 < -1 || ctx->p1 > 1) {
1220 /* Uses the same return value of pkey_ec_ctrl() */
1221 return -2;
1222 }
1223 }
1224
1225 if ((ret = default_fixup_args(state, translation, ctx)) <= 0)
1226 return ret;
1227
1228 if (state == POST_CTRL_TO_PARAMS && ctx->action_type == GET) {
1229 if (ctx->p1 < 0 || ctx->p1 > 1) {
1230 /*
1231 * The provider should return either 0 or 1, any other value is a
1232 * provider error.
1233 */
1234 ctx->p1 = ret = -1;
1235 }
1236 } else if (state == PRE_PARAMS_TO_CTRL && ctx->action_type == GET) {
1237 ctx->p1 = -2;
1238 } else if (state == POST_PARAMS_TO_CTRL && ctx->action_type == GET) {
1239 ctx->p1 = ret;
1240 }
1241
1242 return ret;
1243 }
1244
1245 /* EVP_PKEY_CTRL_RSA_PADDING, EVP_PKEY_CTRL_GET_RSA_PADDING */
fix_rsa_padding_mode(enum state state,const struct translation_st * translation,struct translation_ctx_st * ctx)1246 static int fix_rsa_padding_mode(enum state state,
1247 const struct translation_st *translation,
1248 struct translation_ctx_st *ctx)
1249 {
1250 static const OSSL_ITEM str_value_map[] = {
1251 { RSA_PKCS1_PADDING, "pkcs1" },
1252 { RSA_NO_PADDING, "none" },
1253 { RSA_PKCS1_OAEP_PADDING, "oaep" },
1254 { RSA_PKCS1_OAEP_PADDING, "oeap" },
1255 { RSA_X931_PADDING, "x931" },
1256 { RSA_PKCS1_PSS_PADDING, "pss" },
1257 /* Special case, will pass directly as an integer */
1258 { RSA_PKCS1_WITH_TLS_PADDING, NULL }
1259 };
1260 int ret;
1261
1262 if ((ret = default_check(state, translation, ctx)) <= 0)
1263 return ret;
1264
1265 if (state == PRE_CTRL_TO_PARAMS && ctx->action_type == GET) {
1266 /*
1267 * EVP_PKEY_CTRL_GET_RSA_PADDING returns the padding mode in the
1268 * weirdest way for a ctrl. Instead of doing like all other ctrls
1269 * that return a simple, i.e. just have that as a return value,
1270 * this particular ctrl treats p2 as the address for the int to be
1271 * returned. We must therefore remember |ctx->p2|, then make
1272 * |ctx->p2| point at a buffer to be filled in with the name, and
1273 * |ctx->p1| with its size. default_fixup_args() will take care
1274 * of the rest for us, along with the POST_CTRL_TO_PARAMS && GET
1275 * code section further down.
1276 */
1277 ctx->orig_p2 = ctx->p2;
1278 ctx->p2 = ctx->name_buf;
1279 ctx->p1 = sizeof(ctx->name_buf);
1280 } else if (state == PRE_CTRL_TO_PARAMS && ctx->action_type == SET) {
1281 /*
1282 * Ideally, we should use utf8 strings for the diverse padding modes.
1283 * We only came here because someone called EVP_PKEY_CTX_ctrl(),
1284 * though, and since that can reasonably be seen as legacy code
1285 * that uses the diverse RSA macros for the padding mode, and we
1286 * know that at least our providers can handle the numeric modes,
1287 * we take the cheap route for now.
1288 *
1289 * The other solution would be to match |ctx->p1| against entries
1290 * in str_value_map and pass the corresponding string. However,
1291 * since we don't have a string for RSA_PKCS1_WITH_TLS_PADDING,
1292 * we have to do this same hack at least for that one.
1293 *
1294 * Since the "official" data type for the RSA padding mode is utf8
1295 * string, we cannot count on default_fixup_args(). Instead, we
1296 * build the OSSL_PARAM item ourselves and return immediately.
1297 */
1298 ctx->params[0] = OSSL_PARAM_construct_int(translation->param_key,
1299 &ctx->p1);
1300 return 1;
1301 } else if (state == POST_PARAMS_TO_CTRL && ctx->action_type == GET) {
1302 size_t i;
1303
1304 /*
1305 * The EVP_PKEY_CTX_get_params() caller may have asked for a utf8
1306 * string, or may have asked for an integer of some sort. If they
1307 * ask for an integer, we respond directly. If not, we translate
1308 * the response from the ctrl function into a string.
1309 */
1310 switch (ctx->params->data_type) {
1311 case OSSL_PARAM_INTEGER:
1312 return OSSL_PARAM_get_int(ctx->params, &ctx->p1);
1313 case OSSL_PARAM_UNSIGNED_INTEGER:
1314 return OSSL_PARAM_get_uint(ctx->params, (unsigned int *)&ctx->p1);
1315 default:
1316 break;
1317 }
1318
1319 for (i = 0; i < OSSL_NELEM(str_value_map); i++) {
1320 if (ctx->p1 == (int)str_value_map[i].id)
1321 break;
1322 }
1323 if (i == OSSL_NELEM(str_value_map)) {
1324 ERR_raise_data(ERR_LIB_RSA, RSA_R_UNKNOWN_PADDING_TYPE,
1325 "[action:%d, state:%d] padding number %d",
1326 ctx->action_type, state, ctx->p1);
1327 return -2;
1328 }
1329 /*
1330 * If we don't have a string, we can't do anything. The caller
1331 * should have asked for a number...
1332 */
1333 if (str_value_map[i].ptr == NULL) {
1334 ERR_raise(ERR_LIB_EVP, EVP_R_COMMAND_NOT_SUPPORTED);
1335 return -2;
1336 }
1337 ctx->p2 = str_value_map[i].ptr;
1338 ctx->p1 = strlen(ctx->p2);
1339 }
1340
1341 if ((ret = default_fixup_args(state, translation, ctx)) <= 0)
1342 return ret;
1343
1344 if ((ctx->action_type == SET && state == PRE_PARAMS_TO_CTRL)
1345 || (ctx->action_type == GET && state == POST_CTRL_TO_PARAMS)) {
1346 size_t i;
1347
1348 for (i = 0; i < OSSL_NELEM(str_value_map); i++) {
1349 if (strcmp(ctx->p2, str_value_map[i].ptr) == 0)
1350 break;
1351 }
1352
1353 if (i == OSSL_NELEM(str_value_map)) {
1354 ERR_raise_data(ERR_LIB_RSA, RSA_R_UNKNOWN_PADDING_TYPE,
1355 "[action:%d, state:%d] padding name %s",
1356 ctx->action_type, state, ctx->p1);
1357 ctx->p1 = ret = -2;
1358 } else if (state == POST_CTRL_TO_PARAMS) {
1359 /* EVP_PKEY_CTRL_GET_RSA_PADDING weirdness explained further up */
1360 *(int *)ctx->orig_p2 = str_value_map[i].id;
1361 } else {
1362 ctx->p1 = str_value_map[i].id;
1363 }
1364 ctx->p2 = NULL;
1365 }
1366
1367 return ret;
1368 }
1369
1370 /* EVP_PKEY_CTRL_RSA_PSS_SALTLEN, EVP_PKEY_CTRL_GET_RSA_PSS_SALTLEN */
fix_rsa_pss_saltlen(enum state state,const struct translation_st * translation,struct translation_ctx_st * ctx)1371 static int fix_rsa_pss_saltlen(enum state state,
1372 const struct translation_st *translation,
1373 struct translation_ctx_st *ctx)
1374 {
1375 static const OSSL_ITEM str_value_map[] = {
1376 { (unsigned int)RSA_PSS_SALTLEN_DIGEST, "digest" },
1377 { (unsigned int)RSA_PSS_SALTLEN_MAX, "max" },
1378 { (unsigned int)RSA_PSS_SALTLEN_AUTO, "auto" }
1379 };
1380 int ret;
1381
1382 if ((ret = default_check(state, translation, ctx)) <= 0)
1383 return ret;
1384
1385 if (state == PRE_CTRL_TO_PARAMS && ctx->action_type == GET) {
1386 /*
1387 * EVP_PKEY_CTRL_GET_RSA_PSS_SALTLEN returns the saltlen by filling
1388 * in the int pointed at by p2. This is potentially as weird as
1389 * the way EVP_PKEY_CTRL_GET_RSA_PADDING works, except that saltlen
1390 * might be a negative value, so it wouldn't work as a legitimate
1391 * return value.
1392 * In any case, we must therefore remember |ctx->p2|, then make
1393 * |ctx->p2| point at a buffer to be filled in with the name, and
1394 * |ctx->p1| with its size. default_fixup_args() will take care
1395 * of the rest for us, along with the POST_CTRL_TO_PARAMS && GET
1396 * code section further down.
1397 */
1398 ctx->orig_p2 = ctx->p2;
1399 ctx->p2 = ctx->name_buf;
1400 ctx->p1 = sizeof(ctx->name_buf);
1401 } else if ((ctx->action_type == SET && state == PRE_CTRL_TO_PARAMS)
1402 || (ctx->action_type == GET && state == POST_PARAMS_TO_CTRL)) {
1403 size_t i;
1404
1405 for (i = 0; i < OSSL_NELEM(str_value_map); i++) {
1406 if (ctx->p1 == (int)str_value_map[i].id)
1407 break;
1408 }
1409 if (i == OSSL_NELEM(str_value_map)) {
1410 BIO_snprintf(ctx->name_buf, sizeof(ctx->name_buf), "%d", ctx->p1);
1411 } else {
1412 /* This won't truncate but it will quiet static analysers */
1413 strncpy(ctx->name_buf, str_value_map[i].ptr, sizeof(ctx->name_buf) - 1);
1414 ctx->name_buf[sizeof(ctx->name_buf) - 1] = '\0';
1415 }
1416 ctx->p2 = ctx->name_buf;
1417 ctx->p1 = strlen(ctx->p2);
1418 }
1419
1420 if ((ret = default_fixup_args(state, translation, ctx)) <= 0)
1421 return ret;
1422
1423 if ((ctx->action_type == SET && state == PRE_PARAMS_TO_CTRL)
1424 || (ctx->action_type == GET && state == POST_CTRL_TO_PARAMS)) {
1425 size_t i;
1426 int val;
1427
1428 for (i = 0; i < OSSL_NELEM(str_value_map); i++) {
1429 if (strcmp(ctx->p2, str_value_map[i].ptr) == 0)
1430 break;
1431 }
1432
1433 val = i == OSSL_NELEM(str_value_map) ? atoi(ctx->p2)
1434 : (int)str_value_map[i].id;
1435 if (state == POST_CTRL_TO_PARAMS) {
1436 /*
1437 * EVP_PKEY_CTRL_GET_RSA_PSS_SALTLEN weirdness explained further
1438 * up
1439 */
1440 *(int *)ctx->orig_p2 = val;
1441 } else {
1442 ctx->p1 = val;
1443 }
1444 ctx->p2 = NULL;
1445 }
1446
1447 return ret;
1448 }
1449
1450 /* EVP_PKEY_CTRL_HKDF_MODE */
fix_hkdf_mode(enum state state,const struct translation_st * translation,struct translation_ctx_st * ctx)1451 static int fix_hkdf_mode(enum state state,
1452 const struct translation_st *translation,
1453 struct translation_ctx_st *ctx)
1454 {
1455 static const OSSL_ITEM str_value_map[] = {
1456 { EVP_KDF_HKDF_MODE_EXTRACT_AND_EXPAND, "EXTRACT_AND_EXPAND" },
1457 { EVP_KDF_HKDF_MODE_EXTRACT_ONLY, "EXTRACT_ONLY" },
1458 { EVP_KDF_HKDF_MODE_EXPAND_ONLY, "EXPAND_ONLY" }
1459 };
1460 int ret;
1461
1462 if ((ret = default_check(state, translation, ctx)) <= 0)
1463 return ret;
1464
1465 if ((ctx->action_type == SET && state == PRE_CTRL_TO_PARAMS)
1466 || (ctx->action_type == GET && state == POST_PARAMS_TO_CTRL)) {
1467 size_t i;
1468
1469 for (i = 0; i < OSSL_NELEM(str_value_map); i++) {
1470 if (ctx->p1 == (int)str_value_map[i].id)
1471 break;
1472 }
1473 if (i == OSSL_NELEM(str_value_map))
1474 return 0;
1475 ctx->p2 = str_value_map[i].ptr;
1476 ctx->p1 = strlen(ctx->p2);
1477 }
1478
1479 if ((ret = default_fixup_args(state, translation, ctx)) <= 0)
1480 return ret;
1481
1482 if ((ctx->action_type == SET && state == PRE_PARAMS_TO_CTRL)
1483 || (ctx->action_type == GET && state == POST_CTRL_TO_PARAMS)) {
1484 size_t i;
1485
1486 for (i = 0; i < OSSL_NELEM(str_value_map); i++) {
1487 if (strcmp(ctx->p2, str_value_map[i].ptr) == 0)
1488 break;
1489 }
1490 if (i == OSSL_NELEM(str_value_map))
1491 return 0;
1492 if (state == POST_CTRL_TO_PARAMS)
1493 ret = str_value_map[i].id;
1494 else
1495 ctx->p1 = str_value_map[i].id;
1496 ctx->p2 = NULL;
1497 }
1498
1499 return 1;
1500 }
1501
1502 /*-
1503 * Payload getters
1504 * ===============
1505 *
1506 * These all get the data they want, then call default_fixup_args() as
1507 * a post-ctrl GET fixup. They all get NULL ctx, ctrl_cmd, ctrl_str,
1508 * p1, sz
1509 */
1510
1511 /* Pilfering DH, DSA and EC_KEY */
get_payload_group_name(enum state state,const struct translation_st * translation,struct translation_ctx_st * ctx)1512 static int get_payload_group_name(enum state state,
1513 const struct translation_st *translation,
1514 struct translation_ctx_st *ctx)
1515 {
1516 EVP_PKEY *pkey = ctx->p2;
1517
1518 ctx->p2 = NULL;
1519 switch (EVP_PKEY_get_base_id(pkey)) {
1520 #ifndef OPENSSL_NO_DH
1521 case EVP_PKEY_DH:
1522 {
1523 const DH *dh = EVP_PKEY_get0_DH(pkey);
1524 int uid = DH_get_nid(dh);
1525
1526 if (uid != NID_undef) {
1527 const DH_NAMED_GROUP *dh_group =
1528 ossl_ffc_uid_to_dh_named_group(uid);
1529
1530 ctx->p2 = (char *)ossl_ffc_named_group_get_name(dh_group);
1531 }
1532 }
1533 break;
1534 #endif
1535 #ifndef OPENSSL_NO_EC
1536 case EVP_PKEY_EC:
1537 {
1538 const EC_GROUP *grp =
1539 EC_KEY_get0_group(EVP_PKEY_get0_EC_KEY(pkey));
1540 int nid = NID_undef;
1541
1542 if (grp != NULL)
1543 nid = EC_GROUP_get_curve_name(grp);
1544 if (nid != NID_undef)
1545 ctx->p2 = (char *)OSSL_EC_curve_nid2name(nid);
1546 }
1547 break;
1548 #endif
1549 default:
1550 ERR_raise(ERR_LIB_EVP, EVP_R_UNSUPPORTED_KEY_TYPE);
1551 return 0;
1552 }
1553
1554 /*
1555 * Quietly ignoring unknown groups matches the behaviour on the provider
1556 * side.
1557 */
1558 if (ctx->p2 == NULL)
1559 return 1;
1560
1561 ctx->p1 = strlen(ctx->p2);
1562 return default_fixup_args(state, translation, ctx);
1563 }
1564
get_payload_private_key(enum state state,const struct translation_st * translation,struct translation_ctx_st * ctx)1565 static int get_payload_private_key(enum state state,
1566 const struct translation_st *translation,
1567 struct translation_ctx_st *ctx)
1568 {
1569 EVP_PKEY *pkey = ctx->p2;
1570
1571 ctx->p2 = NULL;
1572 if (ctx->params->data_type != OSSL_PARAM_UNSIGNED_INTEGER)
1573 return 0;
1574
1575 switch (EVP_PKEY_get_base_id(pkey)) {
1576 #ifndef OPENSSL_NO_DH
1577 case EVP_PKEY_DH:
1578 {
1579 const DH *dh = EVP_PKEY_get0_DH(pkey);
1580
1581 ctx->p2 = (BIGNUM *)DH_get0_priv_key(dh);
1582 }
1583 break;
1584 #endif
1585 #ifndef OPENSSL_NO_EC
1586 case EVP_PKEY_EC:
1587 {
1588 const EC_KEY *ec = EVP_PKEY_get0_EC_KEY(pkey);
1589
1590 ctx->p2 = (BIGNUM *)EC_KEY_get0_private_key(ec);
1591 }
1592 break;
1593 #endif
1594 default:
1595 ERR_raise(ERR_LIB_EVP, EVP_R_UNSUPPORTED_KEY_TYPE);
1596 return 0;
1597 }
1598
1599 return default_fixup_args(state, translation, ctx);
1600 }
1601
get_payload_public_key(enum state state,const struct translation_st * translation,struct translation_ctx_st * ctx)1602 static int get_payload_public_key(enum state state,
1603 const struct translation_st *translation,
1604 struct translation_ctx_st *ctx)
1605 {
1606 EVP_PKEY *pkey = ctx->p2;
1607 unsigned char *buf = NULL;
1608 int ret;
1609
1610 ctx->p2 = NULL;
1611 switch (EVP_PKEY_get_base_id(pkey)) {
1612 #ifndef OPENSSL_NO_DH
1613 case EVP_PKEY_DHX:
1614 case EVP_PKEY_DH:
1615 switch (ctx->params->data_type) {
1616 case OSSL_PARAM_OCTET_STRING:
1617 ctx->sz = ossl_dh_key2buf(EVP_PKEY_get0_DH(pkey), &buf, 0, 1);
1618 ctx->p2 = buf;
1619 break;
1620 case OSSL_PARAM_UNSIGNED_INTEGER:
1621 ctx->p2 = (void *)DH_get0_pub_key(EVP_PKEY_get0_DH(pkey));
1622 break;
1623 default:
1624 return 0;
1625 }
1626 break;
1627 #endif
1628 #ifndef OPENSSL_NO_DSA
1629 case EVP_PKEY_DSA:
1630 if (ctx->params->data_type == OSSL_PARAM_UNSIGNED_INTEGER) {
1631 ctx->p2 = (void *)DSA_get0_pub_key(EVP_PKEY_get0_DSA(pkey));
1632 break;
1633 }
1634 return 0;
1635 #endif
1636 #ifndef OPENSSL_NO_EC
1637 case EVP_PKEY_EC:
1638 if (ctx->params->data_type == OSSL_PARAM_OCTET_STRING) {
1639 const EC_KEY *eckey = EVP_PKEY_get0_EC_KEY(pkey);
1640 BN_CTX *bnctx = BN_CTX_new_ex(ossl_ec_key_get_libctx(eckey));
1641 const EC_GROUP *ecg = EC_KEY_get0_group(eckey);
1642 const EC_POINT *point = EC_KEY_get0_public_key(eckey);
1643
1644 if (bnctx == NULL)
1645 return 0;
1646 ctx->sz = EC_POINT_point2buf(ecg, point,
1647 POINT_CONVERSION_COMPRESSED,
1648 &buf, bnctx);
1649 ctx->p2 = buf;
1650 BN_CTX_free(bnctx);
1651 break;
1652 }
1653 return 0;
1654 #endif
1655 default:
1656 ERR_raise(ERR_LIB_EVP, EVP_R_UNSUPPORTED_KEY_TYPE);
1657 return 0;
1658 }
1659
1660 ret = default_fixup_args(state, translation, ctx);
1661 OPENSSL_free(buf);
1662 return ret;
1663 }
1664
get_payload_public_key_ec(enum state state,const struct translation_st * translation,struct translation_ctx_st * ctx)1665 static int get_payload_public_key_ec(enum state state,
1666 const struct translation_st *translation,
1667 struct translation_ctx_st *ctx)
1668 {
1669 #ifndef OPENSSL_NO_EC
1670 EVP_PKEY *pkey = ctx->p2;
1671 const EC_KEY *eckey = EVP_PKEY_get0_EC_KEY(pkey);
1672 BN_CTX *bnctx;
1673 const EC_POINT *point;
1674 const EC_GROUP *ecg;
1675 BIGNUM *x = NULL;
1676 BIGNUM *y = NULL;
1677 int ret = 0;
1678
1679 ctx->p2 = NULL;
1680
1681 if (eckey == NULL) {
1682 ERR_raise(ERR_LIB_EVP, EVP_R_UNSUPPORTED_KEY_TYPE);
1683 return 0;
1684 }
1685
1686 bnctx = BN_CTX_new_ex(ossl_ec_key_get_libctx(eckey));
1687 if (bnctx == NULL)
1688 return 0;
1689
1690 point = EC_KEY_get0_public_key(eckey);
1691 ecg = EC_KEY_get0_group(eckey);
1692
1693 /* Caller should have requested a BN, fail if not */
1694 if (ctx->params->data_type != OSSL_PARAM_UNSIGNED_INTEGER)
1695 goto out;
1696
1697 x = BN_CTX_get(bnctx);
1698 y = BN_CTX_get(bnctx);
1699 if (y == NULL)
1700 goto out;
1701
1702 if (!EC_POINT_get_affine_coordinates(ecg, point, x, y, bnctx))
1703 goto out;
1704
1705 if (strncmp(ctx->params->key, OSSL_PKEY_PARAM_EC_PUB_X, 2) == 0)
1706 ctx->p2 = x;
1707 else if (strncmp(ctx->params->key, OSSL_PKEY_PARAM_EC_PUB_Y, 2) == 0)
1708 ctx->p2 = y;
1709 else
1710 goto out;
1711
1712 /* Return the payload */
1713 ret = default_fixup_args(state, translation, ctx);
1714 out:
1715 BN_CTX_free(bnctx);
1716 return ret;
1717 #else
1718 ERR_raise(ERR_LIB_EVP, EVP_R_UNSUPPORTED_KEY_TYPE);
1719 return 0;
1720 #endif
1721 }
1722
get_payload_bn(enum state state,const struct translation_st * translation,struct translation_ctx_st * ctx,const BIGNUM * bn)1723 static int get_payload_bn(enum state state,
1724 const struct translation_st *translation,
1725 struct translation_ctx_st *ctx, const BIGNUM *bn)
1726 {
1727 if (bn == NULL)
1728 return 0;
1729 if (ctx->params->data_type != OSSL_PARAM_UNSIGNED_INTEGER)
1730 return 0;
1731 ctx->p2 = (BIGNUM *)bn;
1732
1733 return default_fixup_args(state, translation, ctx);
1734 }
1735
get_dh_dsa_payload_p(enum state state,const struct translation_st * translation,struct translation_ctx_st * ctx)1736 static int get_dh_dsa_payload_p(enum state state,
1737 const struct translation_st *translation,
1738 struct translation_ctx_st *ctx)
1739 {
1740 const BIGNUM *bn = NULL;
1741 EVP_PKEY *pkey = ctx->p2;
1742
1743 switch (EVP_PKEY_get_base_id(pkey)) {
1744 #ifndef OPENSSL_NO_DH
1745 case EVP_PKEY_DH:
1746 bn = DH_get0_p(EVP_PKEY_get0_DH(pkey));
1747 break;
1748 #endif
1749 #ifndef OPENSSL_NO_DSA
1750 case EVP_PKEY_DSA:
1751 bn = DSA_get0_p(EVP_PKEY_get0_DSA(pkey));
1752 break;
1753 #endif
1754 default:
1755 ERR_raise(ERR_LIB_EVP, EVP_R_UNSUPPORTED_KEY_TYPE);
1756 }
1757
1758 return get_payload_bn(state, translation, ctx, bn);
1759 }
1760
get_dh_dsa_payload_q(enum state state,const struct translation_st * translation,struct translation_ctx_st * ctx)1761 static int get_dh_dsa_payload_q(enum state state,
1762 const struct translation_st *translation,
1763 struct translation_ctx_st *ctx)
1764 {
1765 const BIGNUM *bn = NULL;
1766
1767 switch (EVP_PKEY_get_base_id(ctx->p2)) {
1768 #ifndef OPENSSL_NO_DH
1769 case EVP_PKEY_DH:
1770 bn = DH_get0_q(EVP_PKEY_get0_DH(ctx->p2));
1771 break;
1772 #endif
1773 #ifndef OPENSSL_NO_DSA
1774 case EVP_PKEY_DSA:
1775 bn = DSA_get0_q(EVP_PKEY_get0_DSA(ctx->p2));
1776 break;
1777 #endif
1778 }
1779
1780 return get_payload_bn(state, translation, ctx, bn);
1781 }
1782
get_dh_dsa_payload_g(enum state state,const struct translation_st * translation,struct translation_ctx_st * ctx)1783 static int get_dh_dsa_payload_g(enum state state,
1784 const struct translation_st *translation,
1785 struct translation_ctx_st *ctx)
1786 {
1787 const BIGNUM *bn = NULL;
1788
1789 switch (EVP_PKEY_get_base_id(ctx->p2)) {
1790 #ifndef OPENSSL_NO_DH
1791 case EVP_PKEY_DH:
1792 bn = DH_get0_g(EVP_PKEY_get0_DH(ctx->p2));
1793 break;
1794 #endif
1795 #ifndef OPENSSL_NO_DSA
1796 case EVP_PKEY_DSA:
1797 bn = DSA_get0_g(EVP_PKEY_get0_DSA(ctx->p2));
1798 break;
1799 #endif
1800 }
1801
1802 return get_payload_bn(state, translation, ctx, bn);
1803 }
1804
get_payload_int(enum state state,const struct translation_st * translation,struct translation_ctx_st * ctx,const int val)1805 static int get_payload_int(enum state state,
1806 const struct translation_st *translation,
1807 struct translation_ctx_st *ctx,
1808 const int val)
1809 {
1810 if (ctx->params->data_type != OSSL_PARAM_INTEGER)
1811 return 0;
1812 ctx->p1 = val;
1813 ctx->p2 = NULL;
1814
1815 return default_fixup_args(state, translation, ctx);
1816 }
1817
get_ec_decoded_from_explicit_params(enum state state,const struct translation_st * translation,struct translation_ctx_st * ctx)1818 static int get_ec_decoded_from_explicit_params(enum state state,
1819 const struct translation_st *translation,
1820 struct translation_ctx_st *ctx)
1821 {
1822 int val = 0;
1823 EVP_PKEY *pkey = ctx->p2;
1824
1825 switch (EVP_PKEY_base_id(pkey)) {
1826 #ifndef OPENSSL_NO_EC
1827 case EVP_PKEY_EC:
1828 val = EC_KEY_decoded_from_explicit_params(EVP_PKEY_get0_EC_KEY(pkey));
1829 if (val < 0) {
1830 ERR_raise(ERR_LIB_EVP, EVP_R_INVALID_KEY);
1831 return 0;
1832 }
1833 break;
1834 #endif
1835 default:
1836 ERR_raise(ERR_LIB_EVP, EVP_R_UNSUPPORTED_KEY_TYPE);
1837 return 0;
1838 }
1839
1840 return get_payload_int(state, translation, ctx, val);
1841 }
1842
get_rsa_payload_n(enum state state,const struct translation_st * translation,struct translation_ctx_st * ctx)1843 static int get_rsa_payload_n(enum state state,
1844 const struct translation_st *translation,
1845 struct translation_ctx_st *ctx)
1846 {
1847 const BIGNUM *bn = NULL;
1848
1849 if (EVP_PKEY_get_base_id(ctx->p2) != EVP_PKEY_RSA
1850 && EVP_PKEY_get_base_id(ctx->p2) != EVP_PKEY_RSA_PSS)
1851 return 0;
1852 bn = RSA_get0_n(EVP_PKEY_get0_RSA(ctx->p2));
1853
1854 return get_payload_bn(state, translation, ctx, bn);
1855 }
1856
get_rsa_payload_e(enum state state,const struct translation_st * translation,struct translation_ctx_st * ctx)1857 static int get_rsa_payload_e(enum state state,
1858 const struct translation_st *translation,
1859 struct translation_ctx_st *ctx)
1860 {
1861 const BIGNUM *bn = NULL;
1862
1863 if (EVP_PKEY_get_base_id(ctx->p2) != EVP_PKEY_RSA
1864 && EVP_PKEY_get_base_id(ctx->p2) != EVP_PKEY_RSA_PSS)
1865 return 0;
1866 bn = RSA_get0_e(EVP_PKEY_get0_RSA(ctx->p2));
1867
1868 return get_payload_bn(state, translation, ctx, bn);
1869 }
1870
get_rsa_payload_d(enum state state,const struct translation_st * translation,struct translation_ctx_st * ctx)1871 static int get_rsa_payload_d(enum state state,
1872 const struct translation_st *translation,
1873 struct translation_ctx_st *ctx)
1874 {
1875 const BIGNUM *bn = NULL;
1876
1877 if (EVP_PKEY_get_base_id(ctx->p2) != EVP_PKEY_RSA
1878 && EVP_PKEY_get_base_id(ctx->p2) != EVP_PKEY_RSA_PSS)
1879 return 0;
1880 bn = RSA_get0_d(EVP_PKEY_get0_RSA(ctx->p2));
1881
1882 return get_payload_bn(state, translation, ctx, bn);
1883 }
1884
get_rsa_payload_factor(enum state state,const struct translation_st * translation,struct translation_ctx_st * ctx,size_t factornum)1885 static int get_rsa_payload_factor(enum state state,
1886 const struct translation_st *translation,
1887 struct translation_ctx_st *ctx,
1888 size_t factornum)
1889 {
1890 const RSA *r = EVP_PKEY_get0_RSA(ctx->p2);
1891 const BIGNUM *bn = NULL;
1892
1893 switch (factornum) {
1894 case 0:
1895 bn = RSA_get0_p(r);
1896 break;
1897 case 1:
1898 bn = RSA_get0_q(r);
1899 break;
1900 default:
1901 {
1902 size_t pnum = RSA_get_multi_prime_extra_count(r);
1903 const BIGNUM *factors[10];
1904
1905 if (factornum - 2 < pnum
1906 && RSA_get0_multi_prime_factors(r, factors))
1907 bn = factors[factornum - 2];
1908 }
1909 break;
1910 }
1911
1912 return get_payload_bn(state, translation, ctx, bn);
1913 }
1914
get_rsa_payload_exponent(enum state state,const struct translation_st * translation,struct translation_ctx_st * ctx,size_t exponentnum)1915 static int get_rsa_payload_exponent(enum state state,
1916 const struct translation_st *translation,
1917 struct translation_ctx_st *ctx,
1918 size_t exponentnum)
1919 {
1920 const RSA *r = EVP_PKEY_get0_RSA(ctx->p2);
1921 const BIGNUM *bn = NULL;
1922
1923 switch (exponentnum) {
1924 case 0:
1925 bn = RSA_get0_dmp1(r);
1926 break;
1927 case 1:
1928 bn = RSA_get0_dmq1(r);
1929 break;
1930 default:
1931 {
1932 size_t pnum = RSA_get_multi_prime_extra_count(r);
1933 const BIGNUM *exps[10], *coeffs[10];
1934
1935 if (exponentnum - 2 < pnum
1936 && RSA_get0_multi_prime_crt_params(r, exps, coeffs))
1937 bn = exps[exponentnum - 2];
1938 }
1939 break;
1940 }
1941
1942 return get_payload_bn(state, translation, ctx, bn);
1943 }
1944
get_rsa_payload_coefficient(enum state state,const struct translation_st * translation,struct translation_ctx_st * ctx,size_t coefficientnum)1945 static int get_rsa_payload_coefficient(enum state state,
1946 const struct translation_st *translation,
1947 struct translation_ctx_st *ctx,
1948 size_t coefficientnum)
1949 {
1950 const RSA *r = EVP_PKEY_get0_RSA(ctx->p2);
1951 const BIGNUM *bn = NULL;
1952
1953 switch (coefficientnum) {
1954 case 0:
1955 bn = RSA_get0_iqmp(r);
1956 break;
1957 default:
1958 {
1959 size_t pnum = RSA_get_multi_prime_extra_count(r);
1960 const BIGNUM *exps[10], *coeffs[10];
1961
1962 if (coefficientnum - 1 < pnum
1963 && RSA_get0_multi_prime_crt_params(r, exps, coeffs))
1964 bn = coeffs[coefficientnum - 1];
1965 }
1966 break;
1967 }
1968
1969 return get_payload_bn(state, translation, ctx, bn);
1970 }
1971
1972 #define IMPL_GET_RSA_PAYLOAD_FACTOR(n) \
1973 static int \
1974 get_rsa_payload_f##n(enum state state, \
1975 const struct translation_st *translation, \
1976 struct translation_ctx_st *ctx) \
1977 { \
1978 if (EVP_PKEY_get_base_id(ctx->p2) != EVP_PKEY_RSA \
1979 && EVP_PKEY_get_base_id(ctx->p2) != EVP_PKEY_RSA_PSS) \
1980 return 0; \
1981 return get_rsa_payload_factor(state, translation, ctx, n - 1); \
1982 }
1983
1984 #define IMPL_GET_RSA_PAYLOAD_EXPONENT(n) \
1985 static int \
1986 get_rsa_payload_e##n(enum state state, \
1987 const struct translation_st *translation, \
1988 struct translation_ctx_st *ctx) \
1989 { \
1990 if (EVP_PKEY_get_base_id(ctx->p2) != EVP_PKEY_RSA \
1991 && EVP_PKEY_get_base_id(ctx->p2) != EVP_PKEY_RSA_PSS) \
1992 return 0; \
1993 return get_rsa_payload_exponent(state, translation, ctx, \
1994 n - 1); \
1995 }
1996
1997 #define IMPL_GET_RSA_PAYLOAD_COEFFICIENT(n) \
1998 static int \
1999 get_rsa_payload_c##n(enum state state, \
2000 const struct translation_st *translation, \
2001 struct translation_ctx_st *ctx) \
2002 { \
2003 if (EVP_PKEY_get_base_id(ctx->p2) != EVP_PKEY_RSA \
2004 && EVP_PKEY_get_base_id(ctx->p2) != EVP_PKEY_RSA_PSS) \
2005 return 0; \
2006 return get_rsa_payload_coefficient(state, translation, ctx, \
2007 n - 1); \
2008 }
2009
2010 IMPL_GET_RSA_PAYLOAD_FACTOR(1)
2011 IMPL_GET_RSA_PAYLOAD_FACTOR(2)
2012 IMPL_GET_RSA_PAYLOAD_FACTOR(3)
2013 IMPL_GET_RSA_PAYLOAD_FACTOR(4)
2014 IMPL_GET_RSA_PAYLOAD_FACTOR(5)
2015 IMPL_GET_RSA_PAYLOAD_FACTOR(6)
2016 IMPL_GET_RSA_PAYLOAD_FACTOR(7)
2017 IMPL_GET_RSA_PAYLOAD_FACTOR(8)
2018 IMPL_GET_RSA_PAYLOAD_FACTOR(9)
2019 IMPL_GET_RSA_PAYLOAD_FACTOR(10)
2020 IMPL_GET_RSA_PAYLOAD_EXPONENT(1)
2021 IMPL_GET_RSA_PAYLOAD_EXPONENT(2)
2022 IMPL_GET_RSA_PAYLOAD_EXPONENT(3)
2023 IMPL_GET_RSA_PAYLOAD_EXPONENT(4)
2024 IMPL_GET_RSA_PAYLOAD_EXPONENT(5)
2025 IMPL_GET_RSA_PAYLOAD_EXPONENT(6)
2026 IMPL_GET_RSA_PAYLOAD_EXPONENT(7)
2027 IMPL_GET_RSA_PAYLOAD_EXPONENT(8)
2028 IMPL_GET_RSA_PAYLOAD_EXPONENT(9)
2029 IMPL_GET_RSA_PAYLOAD_EXPONENT(10)
2030 IMPL_GET_RSA_PAYLOAD_COEFFICIENT(1)
2031 IMPL_GET_RSA_PAYLOAD_COEFFICIENT(2)
2032 IMPL_GET_RSA_PAYLOAD_COEFFICIENT(3)
2033 IMPL_GET_RSA_PAYLOAD_COEFFICIENT(4)
2034 IMPL_GET_RSA_PAYLOAD_COEFFICIENT(5)
2035 IMPL_GET_RSA_PAYLOAD_COEFFICIENT(6)
2036 IMPL_GET_RSA_PAYLOAD_COEFFICIENT(7)
2037 IMPL_GET_RSA_PAYLOAD_COEFFICIENT(8)
2038 IMPL_GET_RSA_PAYLOAD_COEFFICIENT(9)
2039
fix_group_ecx(enum state state,const struct translation_st * translation,struct translation_ctx_st * ctx)2040 static int fix_group_ecx(enum state state,
2041 const struct translation_st *translation,
2042 struct translation_ctx_st *ctx)
2043 {
2044 const char *value = NULL;
2045
2046 switch (state) {
2047 case PRE_PARAMS_TO_CTRL:
2048 if (!EVP_PKEY_CTX_IS_GEN_OP(ctx->pctx))
2049 return 0;
2050 ctx->action_type = NONE;
2051 return 1;
2052 case POST_PARAMS_TO_CTRL:
2053 if (OSSL_PARAM_get_utf8_string_ptr(ctx->params, &value) == 0 ||
2054 OPENSSL_strcasecmp(ctx->pctx->keytype, value) != 0) {
2055 ERR_raise(ERR_LIB_EVP, ERR_R_PASSED_INVALID_ARGUMENT);
2056 ctx->p1 = 0;
2057 return 0;
2058 }
2059 ctx->p1 = 1;
2060 return 1;
2061 default:
2062 return 0;
2063 }
2064 }
2065
2066 /*-
2067 * The translation table itself
2068 * ============================
2069 */
2070
2071 static const struct translation_st evp_pkey_ctx_translations[] = {
2072 /*
2073 * DistID: we pass it to the backend as an octet string,
2074 * but get it back as a pointer to an octet string.
2075 *
2076 * Note that the EVP_PKEY_CTRL_GET1_ID_LEN is purely for legacy purposes
2077 * that has no separate counterpart in OSSL_PARAM terms, since we get
2078 * the length of the DistID automatically when getting the DistID itself.
2079 */
2080 { SET, -1, -1, EVP_PKEY_OP_TYPE_SIG,
2081 EVP_PKEY_CTRL_SET1_ID, "distid", "hexdistid",
2082 OSSL_PKEY_PARAM_DIST_ID, OSSL_PARAM_OCTET_STRING, NULL },
2083 { GET, -1, -1, -1,
2084 EVP_PKEY_CTRL_GET1_ID, "distid", "hexdistid",
2085 OSSL_PKEY_PARAM_DIST_ID, OSSL_PARAM_OCTET_PTR, NULL },
2086 { GET, -1, -1, -1,
2087 EVP_PKEY_CTRL_GET1_ID_LEN, NULL, NULL,
2088 OSSL_PKEY_PARAM_DIST_ID, OSSL_PARAM_OCTET_PTR, fix_distid_len },
2089
2090 /*-
2091 * DH & DHX
2092 * ========
2093 */
2094
2095 /*
2096 * EVP_PKEY_CTRL_DH_KDF_TYPE is used both for setting and getting. The
2097 * fixup function has to handle this...
2098 */
2099 { NONE, EVP_PKEY_DHX, 0, EVP_PKEY_OP_DERIVE,
2100 EVP_PKEY_CTRL_DH_KDF_TYPE, NULL, NULL,
2101 OSSL_EXCHANGE_PARAM_KDF_TYPE, OSSL_PARAM_UTF8_STRING,
2102 fix_dh_kdf_type },
2103 { SET, EVP_PKEY_DHX, 0, EVP_PKEY_OP_DERIVE,
2104 EVP_PKEY_CTRL_DH_KDF_MD, NULL, NULL,
2105 OSSL_EXCHANGE_PARAM_KDF_DIGEST, OSSL_PARAM_UTF8_STRING, fix_md },
2106 { GET, EVP_PKEY_DHX, 0, EVP_PKEY_OP_DERIVE,
2107 EVP_PKEY_CTRL_GET_DH_KDF_MD, NULL, NULL,
2108 OSSL_EXCHANGE_PARAM_KDF_DIGEST, OSSL_PARAM_UTF8_STRING, fix_md },
2109 { SET, EVP_PKEY_DHX, 0, EVP_PKEY_OP_DERIVE,
2110 EVP_PKEY_CTRL_DH_KDF_OUTLEN, NULL, NULL,
2111 OSSL_EXCHANGE_PARAM_KDF_OUTLEN, OSSL_PARAM_UNSIGNED_INTEGER, NULL },
2112 { GET, EVP_PKEY_DHX, 0, EVP_PKEY_OP_DERIVE,
2113 EVP_PKEY_CTRL_GET_DH_KDF_OUTLEN, NULL, NULL,
2114 OSSL_EXCHANGE_PARAM_KDF_OUTLEN, OSSL_PARAM_UNSIGNED_INTEGER, NULL },
2115 { SET, EVP_PKEY_DHX, 0, EVP_PKEY_OP_DERIVE,
2116 EVP_PKEY_CTRL_DH_KDF_UKM, NULL, NULL,
2117 OSSL_EXCHANGE_PARAM_KDF_UKM, OSSL_PARAM_OCTET_STRING, NULL },
2118 { GET, EVP_PKEY_DHX, 0, EVP_PKEY_OP_DERIVE,
2119 EVP_PKEY_CTRL_GET_DH_KDF_UKM, NULL, NULL,
2120 OSSL_EXCHANGE_PARAM_KDF_UKM, OSSL_PARAM_OCTET_PTR, NULL },
2121 { SET, EVP_PKEY_DHX, 0, EVP_PKEY_OP_DERIVE,
2122 EVP_PKEY_CTRL_DH_KDF_OID, NULL, NULL,
2123 OSSL_KDF_PARAM_CEK_ALG, OSSL_PARAM_UTF8_STRING, fix_oid },
2124 { GET, EVP_PKEY_DHX, 0, EVP_PKEY_OP_DERIVE,
2125 EVP_PKEY_CTRL_GET_DH_KDF_OID, NULL, NULL,
2126 OSSL_KDF_PARAM_CEK_ALG, OSSL_PARAM_UTF8_STRING, fix_oid },
2127
2128 /* DHX Keygen Parameters that are shared with DH */
2129 { SET, EVP_PKEY_DHX, 0, EVP_PKEY_OP_PARAMGEN,
2130 EVP_PKEY_CTRL_DH_PARAMGEN_TYPE, "dh_paramgen_type", NULL,
2131 OSSL_PKEY_PARAM_FFC_TYPE, OSSL_PARAM_UTF8_STRING, fix_dh_paramgen_type },
2132 { SET, EVP_PKEY_DHX, 0, EVP_PKEY_OP_PARAMGEN,
2133 EVP_PKEY_CTRL_DH_PARAMGEN_PRIME_LEN, "dh_paramgen_prime_len", NULL,
2134 OSSL_PKEY_PARAM_FFC_PBITS, OSSL_PARAM_UNSIGNED_INTEGER, NULL },
2135 { SET, EVP_PKEY_DHX, 0, EVP_PKEY_OP_PARAMGEN | EVP_PKEY_OP_KEYGEN,
2136 EVP_PKEY_CTRL_DH_NID, "dh_param", NULL,
2137 OSSL_PKEY_PARAM_GROUP_NAME, OSSL_PARAM_UTF8_STRING, NULL },
2138 { SET, EVP_PKEY_DHX, 0, EVP_PKEY_OP_PARAMGEN | EVP_PKEY_OP_KEYGEN,
2139 EVP_PKEY_CTRL_DH_RFC5114, "dh_rfc5114", NULL,
2140 OSSL_PKEY_PARAM_GROUP_NAME, OSSL_PARAM_UTF8_STRING, fix_dh_nid5114 },
2141
2142 /* DH Keygen Parameters that are shared with DHX */
2143 { SET, EVP_PKEY_DH, 0, EVP_PKEY_OP_PARAMGEN,
2144 EVP_PKEY_CTRL_DH_PARAMGEN_TYPE, "dh_paramgen_type", NULL,
2145 OSSL_PKEY_PARAM_FFC_TYPE, OSSL_PARAM_UTF8_STRING, fix_dh_paramgen_type },
2146 { SET, EVP_PKEY_DH, 0, EVP_PKEY_OP_PARAMGEN,
2147 EVP_PKEY_CTRL_DH_PARAMGEN_PRIME_LEN, "dh_paramgen_prime_len", NULL,
2148 OSSL_PKEY_PARAM_FFC_PBITS, OSSL_PARAM_UNSIGNED_INTEGER, NULL },
2149 { SET, EVP_PKEY_DH, 0, EVP_PKEY_OP_PARAMGEN | EVP_PKEY_OP_KEYGEN,
2150 EVP_PKEY_CTRL_DH_NID, "dh_param", NULL,
2151 OSSL_PKEY_PARAM_GROUP_NAME, OSSL_PARAM_UTF8_STRING, fix_dh_nid },
2152 { SET, EVP_PKEY_DH, 0, EVP_PKEY_OP_PARAMGEN | EVP_PKEY_OP_KEYGEN,
2153 EVP_PKEY_CTRL_DH_RFC5114, "dh_rfc5114", NULL,
2154 OSSL_PKEY_PARAM_GROUP_NAME, OSSL_PARAM_UTF8_STRING, fix_dh_nid5114 },
2155
2156 /* DH specific Keygen Parameters */
2157 { SET, EVP_PKEY_DH, 0, EVP_PKEY_OP_PARAMGEN,
2158 EVP_PKEY_CTRL_DH_PARAMGEN_GENERATOR, "dh_paramgen_generator", NULL,
2159 OSSL_PKEY_PARAM_DH_GENERATOR, OSSL_PARAM_INTEGER, NULL },
2160
2161 /* DHX specific Keygen Parameters */
2162 { SET, EVP_PKEY_DHX, 0, EVP_PKEY_OP_PARAMGEN,
2163 EVP_PKEY_CTRL_DH_PARAMGEN_SUBPRIME_LEN, "dh_paramgen_subprime_len", NULL,
2164 OSSL_PKEY_PARAM_FFC_QBITS, OSSL_PARAM_UNSIGNED_INTEGER, NULL },
2165
2166 { SET, EVP_PKEY_DH, 0, EVP_PKEY_OP_DERIVE,
2167 EVP_PKEY_CTRL_DH_PAD, "dh_pad", NULL,
2168 OSSL_EXCHANGE_PARAM_PAD, OSSL_PARAM_UNSIGNED_INTEGER, NULL },
2169
2170 /*-
2171 * DSA
2172 * ===
2173 */
2174 { SET, EVP_PKEY_DSA, 0, EVP_PKEY_OP_PARAMGEN,
2175 EVP_PKEY_CTRL_DSA_PARAMGEN_BITS, "dsa_paramgen_bits", NULL,
2176 OSSL_PKEY_PARAM_FFC_PBITS, OSSL_PARAM_UNSIGNED_INTEGER, NULL },
2177 { SET, EVP_PKEY_DSA, 0, EVP_PKEY_OP_PARAMGEN,
2178 EVP_PKEY_CTRL_DSA_PARAMGEN_Q_BITS, "dsa_paramgen_q_bits", NULL,
2179 OSSL_PKEY_PARAM_FFC_QBITS, OSSL_PARAM_UNSIGNED_INTEGER, NULL },
2180 { SET, EVP_PKEY_DSA, 0, EVP_PKEY_OP_PARAMGEN,
2181 EVP_PKEY_CTRL_DSA_PARAMGEN_MD, "dsa_paramgen_md", NULL,
2182 OSSL_PKEY_PARAM_FFC_DIGEST, OSSL_PARAM_UTF8_STRING, fix_md },
2183
2184 /*-
2185 * EC
2186 * ==
2187 */
2188 { SET, EVP_PKEY_EC, 0, EVP_PKEY_OP_PARAMGEN | EVP_PKEY_OP_KEYGEN,
2189 EVP_PKEY_CTRL_EC_PARAM_ENC, "ec_param_enc", NULL,
2190 OSSL_PKEY_PARAM_EC_ENCODING, OSSL_PARAM_UTF8_STRING, fix_ec_param_enc },
2191 { SET, EVP_PKEY_EC, 0, EVP_PKEY_OP_PARAMGEN | EVP_PKEY_OP_KEYGEN,
2192 EVP_PKEY_CTRL_EC_PARAMGEN_CURVE_NID, "ec_paramgen_curve", NULL,
2193 OSSL_PKEY_PARAM_GROUP_NAME, OSSL_PARAM_UTF8_STRING,
2194 fix_ec_paramgen_curve_nid },
2195 /*
2196 * EVP_PKEY_CTRL_EC_ECDH_COFACTOR and EVP_PKEY_CTRL_EC_KDF_TYPE are used
2197 * both for setting and getting. The fixup function has to handle this...
2198 */
2199 { NONE, EVP_PKEY_EC, 0, EVP_PKEY_OP_DERIVE,
2200 EVP_PKEY_CTRL_EC_ECDH_COFACTOR, "ecdh_cofactor_mode", NULL,
2201 OSSL_EXCHANGE_PARAM_EC_ECDH_COFACTOR_MODE, OSSL_PARAM_INTEGER,
2202 fix_ecdh_cofactor },
2203 { NONE, EVP_PKEY_EC, 0, EVP_PKEY_OP_DERIVE,
2204 EVP_PKEY_CTRL_EC_KDF_TYPE, NULL, NULL,
2205 OSSL_EXCHANGE_PARAM_KDF_TYPE, OSSL_PARAM_UTF8_STRING, fix_ec_kdf_type },
2206 { SET, EVP_PKEY_EC, 0, EVP_PKEY_OP_DERIVE,
2207 EVP_PKEY_CTRL_EC_KDF_MD, "ecdh_kdf_md", NULL,
2208 OSSL_EXCHANGE_PARAM_KDF_DIGEST, OSSL_PARAM_UTF8_STRING, fix_md },
2209 { GET, EVP_PKEY_EC, 0, EVP_PKEY_OP_DERIVE,
2210 EVP_PKEY_CTRL_GET_EC_KDF_MD, NULL, NULL,
2211 OSSL_EXCHANGE_PARAM_KDF_DIGEST, OSSL_PARAM_UTF8_STRING, fix_md },
2212 { SET, EVP_PKEY_EC, 0, EVP_PKEY_OP_DERIVE,
2213 EVP_PKEY_CTRL_EC_KDF_OUTLEN, NULL, NULL,
2214 OSSL_EXCHANGE_PARAM_KDF_OUTLEN, OSSL_PARAM_UNSIGNED_INTEGER, NULL },
2215 { GET, EVP_PKEY_EC, 0, EVP_PKEY_OP_DERIVE,
2216 EVP_PKEY_CTRL_GET_EC_KDF_OUTLEN, NULL, NULL,
2217 OSSL_EXCHANGE_PARAM_KDF_OUTLEN, OSSL_PARAM_UNSIGNED_INTEGER, NULL },
2218 { SET, EVP_PKEY_EC, 0, EVP_PKEY_OP_DERIVE,
2219 EVP_PKEY_CTRL_EC_KDF_UKM, NULL, NULL,
2220 OSSL_EXCHANGE_PARAM_KDF_UKM, OSSL_PARAM_OCTET_STRING, NULL },
2221 { GET, EVP_PKEY_EC, 0, EVP_PKEY_OP_DERIVE,
2222 EVP_PKEY_CTRL_GET_EC_KDF_UKM, NULL, NULL,
2223 OSSL_EXCHANGE_PARAM_KDF_UKM, OSSL_PARAM_OCTET_PTR, NULL },
2224
2225 /*-
2226 * SM2
2227 * ==
2228 */
2229 { SET, EVP_PKEY_SM2, 0, EVP_PKEY_OP_PARAMGEN | EVP_PKEY_OP_KEYGEN,
2230 EVP_PKEY_CTRL_EC_PARAM_ENC, "ec_param_enc", NULL,
2231 OSSL_PKEY_PARAM_EC_ENCODING, OSSL_PARAM_UTF8_STRING, fix_ec_param_enc },
2232 { SET, EVP_PKEY_SM2, 0, EVP_PKEY_OP_PARAMGEN | EVP_PKEY_OP_KEYGEN,
2233 EVP_PKEY_CTRL_EC_PARAMGEN_CURVE_NID, "ec_paramgen_curve", NULL,
2234 OSSL_PKEY_PARAM_GROUP_NAME, OSSL_PARAM_UTF8_STRING,
2235 fix_ec_paramgen_curve_nid },
2236 /*
2237 * EVP_PKEY_CTRL_EC_ECDH_COFACTOR and EVP_PKEY_CTRL_EC_KDF_TYPE are used
2238 * both for setting and getting. The fixup function has to handle this...
2239 */
2240 { NONE, EVP_PKEY_SM2, 0, EVP_PKEY_OP_DERIVE,
2241 EVP_PKEY_CTRL_EC_ECDH_COFACTOR, "ecdh_cofactor_mode", NULL,
2242 OSSL_EXCHANGE_PARAM_EC_ECDH_COFACTOR_MODE, OSSL_PARAM_INTEGER,
2243 fix_ecdh_cofactor },
2244 { NONE, EVP_PKEY_SM2, 0, EVP_PKEY_OP_DERIVE,
2245 EVP_PKEY_CTRL_EC_KDF_TYPE, NULL, NULL,
2246 OSSL_EXCHANGE_PARAM_KDF_TYPE, OSSL_PARAM_UTF8_STRING, fix_ec_kdf_type },
2247 { SET, EVP_PKEY_SM2, 0, EVP_PKEY_OP_DERIVE,
2248 EVP_PKEY_CTRL_EC_KDF_MD, "ecdh_kdf_md", NULL,
2249 OSSL_EXCHANGE_PARAM_KDF_DIGEST, OSSL_PARAM_UTF8_STRING, fix_md },
2250 { GET, EVP_PKEY_SM2, 0, EVP_PKEY_OP_DERIVE,
2251 EVP_PKEY_CTRL_GET_EC_KDF_MD, NULL, NULL,
2252 OSSL_EXCHANGE_PARAM_KDF_DIGEST, OSSL_PARAM_UTF8_STRING, fix_md },
2253 { SET, EVP_PKEY_SM2, 0, EVP_PKEY_OP_DERIVE,
2254 EVP_PKEY_CTRL_EC_KDF_OUTLEN, NULL, NULL,
2255 OSSL_EXCHANGE_PARAM_KDF_OUTLEN, OSSL_PARAM_UNSIGNED_INTEGER, NULL },
2256 { GET, EVP_PKEY_SM2, 0, EVP_PKEY_OP_DERIVE,
2257 EVP_PKEY_CTRL_GET_EC_KDF_OUTLEN, NULL, NULL,
2258 OSSL_EXCHANGE_PARAM_KDF_OUTLEN, OSSL_PARAM_UNSIGNED_INTEGER, NULL },
2259 { SET, EVP_PKEY_SM2, 0, EVP_PKEY_OP_DERIVE,
2260 EVP_PKEY_CTRL_EC_KDF_UKM, NULL, NULL,
2261 OSSL_EXCHANGE_PARAM_KDF_UKM, OSSL_PARAM_OCTET_STRING, NULL },
2262 { GET, EVP_PKEY_SM2, 0, EVP_PKEY_OP_DERIVE,
2263 EVP_PKEY_CTRL_GET_EC_KDF_UKM, NULL, NULL,
2264 OSSL_EXCHANGE_PARAM_KDF_UKM, OSSL_PARAM_OCTET_PTR, NULL },
2265 /*-
2266 * RSA
2267 * ===
2268 */
2269
2270 /*
2271 * RSA padding modes are numeric with ctrls, strings with ctrl_strs,
2272 * and can be both with OSSL_PARAM. We standardise on strings here,
2273 * fix_rsa_padding_mode() does the work when the caller has a different
2274 * idea.
2275 */
2276 { SET, EVP_PKEY_RSA, EVP_PKEY_RSA_PSS,
2277 EVP_PKEY_OP_TYPE_CRYPT | EVP_PKEY_OP_TYPE_SIG,
2278 EVP_PKEY_CTRL_RSA_PADDING, "rsa_padding_mode", NULL,
2279 OSSL_PKEY_PARAM_PAD_MODE, OSSL_PARAM_UTF8_STRING, fix_rsa_padding_mode },
2280 { GET, EVP_PKEY_RSA, EVP_PKEY_RSA_PSS,
2281 EVP_PKEY_OP_TYPE_CRYPT | EVP_PKEY_OP_TYPE_SIG,
2282 EVP_PKEY_CTRL_GET_RSA_PADDING, NULL, NULL,
2283 OSSL_PKEY_PARAM_PAD_MODE, OSSL_PARAM_UTF8_STRING, fix_rsa_padding_mode },
2284
2285 { SET, EVP_PKEY_RSA, EVP_PKEY_RSA_PSS,
2286 EVP_PKEY_OP_TYPE_CRYPT | EVP_PKEY_OP_TYPE_SIG,
2287 EVP_PKEY_CTRL_RSA_MGF1_MD, "rsa_mgf1_md", NULL,
2288 OSSL_PKEY_PARAM_MGF1_DIGEST, OSSL_PARAM_UTF8_STRING, fix_md },
2289 { GET, EVP_PKEY_RSA, EVP_PKEY_RSA_PSS,
2290 EVP_PKEY_OP_TYPE_CRYPT | EVP_PKEY_OP_TYPE_SIG,
2291 EVP_PKEY_CTRL_GET_RSA_MGF1_MD, NULL, NULL,
2292 OSSL_PKEY_PARAM_MGF1_DIGEST, OSSL_PARAM_UTF8_STRING, fix_md },
2293
2294 /*
2295 * RSA-PSS saltlen is essentially numeric, but certain values can be
2296 * expressed as keywords (strings) with ctrl_str. The corresponding
2297 * OSSL_PARAM allows both forms.
2298 * fix_rsa_pss_saltlen() takes care of the distinction.
2299 */
2300 { SET, EVP_PKEY_RSA, EVP_PKEY_RSA_PSS, EVP_PKEY_OP_TYPE_SIG,
2301 EVP_PKEY_CTRL_RSA_PSS_SALTLEN, "rsa_pss_saltlen", NULL,
2302 OSSL_PKEY_PARAM_RSA_PSS_SALTLEN, OSSL_PARAM_UTF8_STRING,
2303 fix_rsa_pss_saltlen },
2304 { GET, EVP_PKEY_RSA, EVP_PKEY_RSA_PSS, EVP_PKEY_OP_TYPE_SIG,
2305 EVP_PKEY_CTRL_GET_RSA_PSS_SALTLEN, NULL, NULL,
2306 OSSL_PKEY_PARAM_RSA_PSS_SALTLEN, OSSL_PARAM_UTF8_STRING,
2307 fix_rsa_pss_saltlen },
2308
2309 { SET, EVP_PKEY_RSA, 0, EVP_PKEY_OP_TYPE_CRYPT,
2310 EVP_PKEY_CTRL_RSA_OAEP_MD, "rsa_oaep_md", NULL,
2311 OSSL_ASYM_CIPHER_PARAM_OAEP_DIGEST, OSSL_PARAM_UTF8_STRING, fix_md },
2312 { GET, EVP_PKEY_RSA, 0, EVP_PKEY_OP_TYPE_CRYPT,
2313 EVP_PKEY_CTRL_GET_RSA_OAEP_MD, NULL, NULL,
2314 OSSL_ASYM_CIPHER_PARAM_OAEP_DIGEST, OSSL_PARAM_UTF8_STRING, fix_md },
2315 /*
2316 * The "rsa_oaep_label" ctrl_str expects the value to always be hex.
2317 * This is accommodated by default_fixup_args() above, which mimics that
2318 * expectation for any translation item where |ctrl_str| is NULL and
2319 * |ctrl_hexstr| is non-NULL.
2320 */
2321 { SET, EVP_PKEY_RSA, 0, EVP_PKEY_OP_TYPE_CRYPT,
2322 EVP_PKEY_CTRL_RSA_OAEP_LABEL, NULL, "rsa_oaep_label",
2323 OSSL_ASYM_CIPHER_PARAM_OAEP_LABEL, OSSL_PARAM_OCTET_STRING, NULL },
2324 { GET, EVP_PKEY_RSA, 0, EVP_PKEY_OP_TYPE_CRYPT,
2325 EVP_PKEY_CTRL_GET_RSA_OAEP_LABEL, NULL, NULL,
2326 OSSL_ASYM_CIPHER_PARAM_OAEP_LABEL, OSSL_PARAM_OCTET_PTR, NULL },
2327
2328 { SET, EVP_PKEY_RSA, 0, EVP_PKEY_OP_TYPE_CRYPT,
2329 EVP_PKEY_CTRL_RSA_IMPLICIT_REJECTION, NULL,
2330 "rsa_pkcs1_implicit_rejection",
2331 OSSL_ASYM_CIPHER_PARAM_IMPLICIT_REJECTION, OSSL_PARAM_UNSIGNED_INTEGER,
2332 NULL },
2333
2334 { SET, EVP_PKEY_RSA_PSS, 0, EVP_PKEY_OP_TYPE_GEN,
2335 EVP_PKEY_CTRL_MD, "rsa_pss_keygen_md", NULL,
2336 OSSL_ALG_PARAM_DIGEST, OSSL_PARAM_UTF8_STRING, fix_md },
2337 { SET, EVP_PKEY_RSA_PSS, 0, EVP_PKEY_OP_TYPE_GEN,
2338 EVP_PKEY_CTRL_RSA_MGF1_MD, "rsa_pss_keygen_mgf1_md", NULL,
2339 OSSL_PKEY_PARAM_MGF1_DIGEST, OSSL_PARAM_UTF8_STRING, fix_md },
2340 { SET, EVP_PKEY_RSA_PSS, 0, EVP_PKEY_OP_TYPE_GEN,
2341 EVP_PKEY_CTRL_RSA_PSS_SALTLEN, "rsa_pss_keygen_saltlen", NULL,
2342 OSSL_SIGNATURE_PARAM_PSS_SALTLEN, OSSL_PARAM_INTEGER, NULL },
2343 { SET, EVP_PKEY_RSA, EVP_PKEY_RSA_PSS, EVP_PKEY_OP_KEYGEN,
2344 EVP_PKEY_CTRL_RSA_KEYGEN_BITS, "rsa_keygen_bits", NULL,
2345 OSSL_PKEY_PARAM_RSA_BITS, OSSL_PARAM_UNSIGNED_INTEGER, NULL },
2346 { SET, EVP_PKEY_RSA, EVP_PKEY_RSA_PSS, EVP_PKEY_OP_KEYGEN,
2347 EVP_PKEY_CTRL_RSA_KEYGEN_PUBEXP, "rsa_keygen_pubexp", NULL,
2348 OSSL_PKEY_PARAM_RSA_E, OSSL_PARAM_UNSIGNED_INTEGER, NULL },
2349 { SET, EVP_PKEY_RSA, EVP_PKEY_RSA_PSS, EVP_PKEY_OP_KEYGEN,
2350 EVP_PKEY_CTRL_RSA_KEYGEN_PRIMES, "rsa_keygen_primes", NULL,
2351 OSSL_PKEY_PARAM_RSA_PRIMES, OSSL_PARAM_UNSIGNED_INTEGER, NULL },
2352
2353 /*-
2354 * SipHash
2355 * ======
2356 */
2357 { SET, -1, -1, EVP_PKEY_OP_TYPE_SIG,
2358 EVP_PKEY_CTRL_SET_DIGEST_SIZE, "digestsize", NULL,
2359 OSSL_MAC_PARAM_SIZE, OSSL_PARAM_UNSIGNED_INTEGER, NULL },
2360
2361 /*-
2362 * TLS1-PRF
2363 * ========
2364 */
2365 { SET, -1, -1, EVP_PKEY_OP_DERIVE,
2366 EVP_PKEY_CTRL_TLS_MD, "md", NULL,
2367 OSSL_KDF_PARAM_DIGEST, OSSL_PARAM_UTF8_STRING, fix_md },
2368 { SET, -1, -1, EVP_PKEY_OP_DERIVE,
2369 EVP_PKEY_CTRL_TLS_SECRET, "secret", "hexsecret",
2370 OSSL_KDF_PARAM_SECRET, OSSL_PARAM_OCTET_STRING, NULL },
2371 { SET, -1, -1, EVP_PKEY_OP_DERIVE,
2372 EVP_PKEY_CTRL_TLS_SEED, "seed", "hexseed",
2373 OSSL_KDF_PARAM_SEED, OSSL_PARAM_OCTET_STRING, NULL },
2374
2375 /*-
2376 * HKDF
2377 * ====
2378 */
2379 { SET, -1, -1, EVP_PKEY_OP_DERIVE,
2380 EVP_PKEY_CTRL_HKDF_MD, "md", NULL,
2381 OSSL_KDF_PARAM_DIGEST, OSSL_PARAM_UTF8_STRING, fix_md },
2382 { SET, -1, -1, EVP_PKEY_OP_DERIVE,
2383 EVP_PKEY_CTRL_HKDF_SALT, "salt", "hexsalt",
2384 OSSL_KDF_PARAM_SALT, OSSL_PARAM_OCTET_STRING, NULL },
2385 { SET, -1, -1, EVP_PKEY_OP_DERIVE,
2386 EVP_PKEY_CTRL_HKDF_KEY, "key", "hexkey",
2387 OSSL_KDF_PARAM_KEY, OSSL_PARAM_OCTET_STRING, NULL },
2388 { SET, -1, -1, EVP_PKEY_OP_DERIVE,
2389 EVP_PKEY_CTRL_HKDF_INFO, "info", "hexinfo",
2390 OSSL_KDF_PARAM_INFO, OSSL_PARAM_OCTET_STRING, NULL },
2391 { SET, -1, -1, EVP_PKEY_OP_DERIVE,
2392 EVP_PKEY_CTRL_HKDF_MODE, "mode", NULL,
2393 OSSL_KDF_PARAM_MODE, OSSL_PARAM_INTEGER, fix_hkdf_mode },
2394
2395 /*-
2396 * Scrypt
2397 * ======
2398 */
2399 { SET, -1, -1, EVP_PKEY_OP_DERIVE,
2400 EVP_PKEY_CTRL_PASS, "pass", "hexpass",
2401 OSSL_KDF_PARAM_PASSWORD, OSSL_PARAM_OCTET_STRING, NULL },
2402 { SET, -1, -1, EVP_PKEY_OP_DERIVE,
2403 EVP_PKEY_CTRL_SCRYPT_SALT, "salt", "hexsalt",
2404 OSSL_KDF_PARAM_SALT, OSSL_PARAM_OCTET_STRING, NULL },
2405 { SET, -1, -1, EVP_PKEY_OP_DERIVE,
2406 EVP_PKEY_CTRL_SCRYPT_N, "N", NULL,
2407 OSSL_KDF_PARAM_SCRYPT_N, OSSL_PARAM_UNSIGNED_INTEGER, NULL },
2408 { SET, -1, -1, EVP_PKEY_OP_DERIVE,
2409 EVP_PKEY_CTRL_SCRYPT_R, "r", NULL,
2410 OSSL_KDF_PARAM_SCRYPT_R, OSSL_PARAM_UNSIGNED_INTEGER, NULL },
2411 { SET, -1, -1, EVP_PKEY_OP_DERIVE,
2412 EVP_PKEY_CTRL_SCRYPT_P, "p", NULL,
2413 OSSL_KDF_PARAM_SCRYPT_P, OSSL_PARAM_UNSIGNED_INTEGER, NULL },
2414 { SET, -1, -1, EVP_PKEY_OP_DERIVE,
2415 EVP_PKEY_CTRL_SCRYPT_MAXMEM_BYTES, "maxmem_bytes", NULL,
2416 OSSL_KDF_PARAM_SCRYPT_MAXMEM, OSSL_PARAM_UNSIGNED_INTEGER, NULL },
2417
2418 { SET, -1, -1, EVP_PKEY_OP_KEYGEN | EVP_PKEY_OP_TYPE_CRYPT,
2419 EVP_PKEY_CTRL_CIPHER, NULL, NULL,
2420 OSSL_PKEY_PARAM_CIPHER, OSSL_PARAM_UTF8_STRING, fix_cipher },
2421 { SET, -1, -1, EVP_PKEY_OP_KEYGEN,
2422 EVP_PKEY_CTRL_SET_MAC_KEY, "key", "hexkey",
2423 OSSL_PKEY_PARAM_PRIV_KEY, OSSL_PARAM_OCTET_STRING, NULL },
2424
2425 { SET, -1, -1, EVP_PKEY_OP_TYPE_SIG,
2426 EVP_PKEY_CTRL_MD, NULL, NULL,
2427 OSSL_SIGNATURE_PARAM_DIGEST, OSSL_PARAM_UTF8_STRING, fix_md },
2428 { GET, -1, -1, EVP_PKEY_OP_TYPE_SIG,
2429 EVP_PKEY_CTRL_GET_MD, NULL, NULL,
2430 OSSL_SIGNATURE_PARAM_DIGEST, OSSL_PARAM_UTF8_STRING, fix_md },
2431
2432 /*-
2433 * ECX
2434 * ===
2435 */
2436 { SET, EVP_PKEY_X25519, EVP_PKEY_X25519, EVP_PKEY_OP_KEYGEN, -1, NULL, NULL,
2437 OSSL_PKEY_PARAM_GROUP_NAME, OSSL_PARAM_UTF8_STRING, fix_group_ecx },
2438 { SET, EVP_PKEY_X25519, EVP_PKEY_X25519, EVP_PKEY_OP_PARAMGEN, -1, NULL, NULL,
2439 OSSL_PKEY_PARAM_GROUP_NAME, OSSL_PARAM_UTF8_STRING, fix_group_ecx },
2440 { SET, EVP_PKEY_X448, EVP_PKEY_X448, EVP_PKEY_OP_KEYGEN, -1, NULL, NULL,
2441 OSSL_PKEY_PARAM_GROUP_NAME, OSSL_PARAM_UTF8_STRING, fix_group_ecx },
2442 { SET, EVP_PKEY_X448, EVP_PKEY_X448, EVP_PKEY_OP_PARAMGEN, -1, NULL, NULL,
2443 OSSL_PKEY_PARAM_GROUP_NAME, OSSL_PARAM_UTF8_STRING, fix_group_ecx },
2444 };
2445
2446 static const struct translation_st evp_pkey_translations[] = {
2447 /*
2448 * The following contain no ctrls, they are exclusively here to extract
2449 * key payloads from legacy keys, using OSSL_PARAMs, and rely entirely
2450 * on |fixup_args| to pass the actual data. The |fixup_args| should
2451 * expect to get the EVP_PKEY pointer through |ctx->p2|.
2452 */
2453
2454 /* DH, DSA & EC */
2455 { GET, -1, -1, -1, 0, NULL, NULL,
2456 OSSL_PKEY_PARAM_GROUP_NAME, OSSL_PARAM_UTF8_STRING,
2457 get_payload_group_name },
2458 { GET, -1, -1, -1, 0, NULL, NULL,
2459 OSSL_PKEY_PARAM_PRIV_KEY, OSSL_PARAM_UNSIGNED_INTEGER,
2460 get_payload_private_key },
2461 { GET, -1, -1, -1, 0, NULL, NULL,
2462 OSSL_PKEY_PARAM_PUB_KEY,
2463 0 /* no data type, let get_payload_public_key() handle that */,
2464 get_payload_public_key },
2465 { GET, -1, -1, -1, 0, NULL, NULL,
2466 OSSL_PKEY_PARAM_EC_PUB_X, OSSL_PARAM_UNSIGNED_INTEGER,
2467 get_payload_public_key_ec },
2468 { GET, -1, -1, -1, 0, NULL, NULL,
2469 OSSL_PKEY_PARAM_EC_PUB_Y, OSSL_PARAM_UNSIGNED_INTEGER,
2470 get_payload_public_key_ec },
2471
2472 /* DH and DSA */
2473 { GET, -1, -1, -1, 0, NULL, NULL,
2474 OSSL_PKEY_PARAM_FFC_P, OSSL_PARAM_UNSIGNED_INTEGER,
2475 get_dh_dsa_payload_p },
2476 { GET, -1, -1, -1, 0, NULL, NULL,
2477 OSSL_PKEY_PARAM_FFC_G, OSSL_PARAM_UNSIGNED_INTEGER,
2478 get_dh_dsa_payload_g },
2479 { GET, -1, -1, -1, 0, NULL, NULL,
2480 OSSL_PKEY_PARAM_FFC_Q, OSSL_PARAM_UNSIGNED_INTEGER,
2481 get_dh_dsa_payload_q },
2482
2483 /* RSA */
2484 { GET, -1, -1, -1, 0, NULL, NULL,
2485 OSSL_PKEY_PARAM_RSA_N, OSSL_PARAM_UNSIGNED_INTEGER,
2486 get_rsa_payload_n },
2487 { GET, -1, -1, -1, 0, NULL, NULL,
2488 OSSL_PKEY_PARAM_RSA_E, OSSL_PARAM_UNSIGNED_INTEGER,
2489 get_rsa_payload_e },
2490 { GET, -1, -1, -1, 0, NULL, NULL,
2491 OSSL_PKEY_PARAM_RSA_D, OSSL_PARAM_UNSIGNED_INTEGER,
2492 get_rsa_payload_d },
2493 { GET, -1, -1, -1, 0, NULL, NULL,
2494 OSSL_PKEY_PARAM_RSA_FACTOR1, OSSL_PARAM_UNSIGNED_INTEGER,
2495 get_rsa_payload_f1 },
2496 { GET, -1, -1, -1, 0, NULL, NULL,
2497 OSSL_PKEY_PARAM_RSA_FACTOR2, OSSL_PARAM_UNSIGNED_INTEGER,
2498 get_rsa_payload_f2 },
2499 { GET, -1, -1, -1, 0, NULL, NULL,
2500 OSSL_PKEY_PARAM_RSA_FACTOR3, OSSL_PARAM_UNSIGNED_INTEGER,
2501 get_rsa_payload_f3 },
2502 { GET, -1, -1, -1, 0, NULL, NULL,
2503 OSSL_PKEY_PARAM_RSA_FACTOR4, OSSL_PARAM_UNSIGNED_INTEGER,
2504 get_rsa_payload_f4 },
2505 { GET, -1, -1, -1, 0, NULL, NULL,
2506 OSSL_PKEY_PARAM_RSA_FACTOR5, OSSL_PARAM_UNSIGNED_INTEGER,
2507 get_rsa_payload_f5 },
2508 { GET, -1, -1, -1, 0, NULL, NULL,
2509 OSSL_PKEY_PARAM_RSA_FACTOR6, OSSL_PARAM_UNSIGNED_INTEGER,
2510 get_rsa_payload_f6 },
2511 { GET, -1, -1, -1, 0, NULL, NULL,
2512 OSSL_PKEY_PARAM_RSA_FACTOR7, OSSL_PARAM_UNSIGNED_INTEGER,
2513 get_rsa_payload_f7 },
2514 { GET, -1, -1, -1, 0, NULL, NULL,
2515 OSSL_PKEY_PARAM_RSA_FACTOR8, OSSL_PARAM_UNSIGNED_INTEGER,
2516 get_rsa_payload_f8 },
2517 { GET, -1, -1, -1, 0, NULL, NULL,
2518 OSSL_PKEY_PARAM_RSA_FACTOR9, OSSL_PARAM_UNSIGNED_INTEGER,
2519 get_rsa_payload_f9 },
2520 { GET, -1, -1, -1, 0, NULL, NULL,
2521 OSSL_PKEY_PARAM_RSA_FACTOR10, OSSL_PARAM_UNSIGNED_INTEGER,
2522 get_rsa_payload_f10 },
2523 { GET, -1, -1, -1, 0, NULL, NULL,
2524 OSSL_PKEY_PARAM_RSA_EXPONENT1, OSSL_PARAM_UNSIGNED_INTEGER,
2525 get_rsa_payload_e1 },
2526 { GET, -1, -1, -1, 0, NULL, NULL,
2527 OSSL_PKEY_PARAM_RSA_EXPONENT2, OSSL_PARAM_UNSIGNED_INTEGER,
2528 get_rsa_payload_e2 },
2529 { GET, -1, -1, -1, 0, NULL, NULL,
2530 OSSL_PKEY_PARAM_RSA_EXPONENT3, OSSL_PARAM_UNSIGNED_INTEGER,
2531 get_rsa_payload_e3 },
2532 { GET, -1, -1, -1, 0, NULL, NULL,
2533 OSSL_PKEY_PARAM_RSA_EXPONENT4, OSSL_PARAM_UNSIGNED_INTEGER,
2534 get_rsa_payload_e4 },
2535 { GET, -1, -1, -1, 0, NULL, NULL,
2536 OSSL_PKEY_PARAM_RSA_EXPONENT5, OSSL_PARAM_UNSIGNED_INTEGER,
2537 get_rsa_payload_e5 },
2538 { GET, -1, -1, -1, 0, NULL, NULL,
2539 OSSL_PKEY_PARAM_RSA_EXPONENT6, OSSL_PARAM_UNSIGNED_INTEGER,
2540 get_rsa_payload_e6 },
2541 { GET, -1, -1, -1, 0, NULL, NULL,
2542 OSSL_PKEY_PARAM_RSA_EXPONENT7, OSSL_PARAM_UNSIGNED_INTEGER,
2543 get_rsa_payload_e7 },
2544 { GET, -1, -1, -1, 0, NULL, NULL,
2545 OSSL_PKEY_PARAM_RSA_EXPONENT8, OSSL_PARAM_UNSIGNED_INTEGER,
2546 get_rsa_payload_e8 },
2547 { GET, -1, -1, -1, 0, NULL, NULL,
2548 OSSL_PKEY_PARAM_RSA_EXPONENT9, OSSL_PARAM_UNSIGNED_INTEGER,
2549 get_rsa_payload_e9 },
2550 { GET, -1, -1, -1, 0, NULL, NULL,
2551 OSSL_PKEY_PARAM_RSA_EXPONENT10, OSSL_PARAM_UNSIGNED_INTEGER,
2552 get_rsa_payload_e10 },
2553 { GET, -1, -1, -1, 0, NULL, NULL,
2554 OSSL_PKEY_PARAM_RSA_COEFFICIENT1, OSSL_PARAM_UNSIGNED_INTEGER,
2555 get_rsa_payload_c1 },
2556 { GET, -1, -1, -1, 0, NULL, NULL,
2557 OSSL_PKEY_PARAM_RSA_COEFFICIENT2, OSSL_PARAM_UNSIGNED_INTEGER,
2558 get_rsa_payload_c2 },
2559 { GET, -1, -1, -1, 0, NULL, NULL,
2560 OSSL_PKEY_PARAM_RSA_COEFFICIENT3, OSSL_PARAM_UNSIGNED_INTEGER,
2561 get_rsa_payload_c3 },
2562 { GET, -1, -1, -1, 0, NULL, NULL,
2563 OSSL_PKEY_PARAM_RSA_COEFFICIENT4, OSSL_PARAM_UNSIGNED_INTEGER,
2564 get_rsa_payload_c4 },
2565 { GET, -1, -1, -1, 0, NULL, NULL,
2566 OSSL_PKEY_PARAM_RSA_COEFFICIENT5, OSSL_PARAM_UNSIGNED_INTEGER,
2567 get_rsa_payload_c5 },
2568 { GET, -1, -1, -1, 0, NULL, NULL,
2569 OSSL_PKEY_PARAM_RSA_COEFFICIENT6, OSSL_PARAM_UNSIGNED_INTEGER,
2570 get_rsa_payload_c6 },
2571 { GET, -1, -1, -1, 0, NULL, NULL,
2572 OSSL_PKEY_PARAM_RSA_COEFFICIENT7, OSSL_PARAM_UNSIGNED_INTEGER,
2573 get_rsa_payload_c7 },
2574 { GET, -1, -1, -1, 0, NULL, NULL,
2575 OSSL_PKEY_PARAM_RSA_COEFFICIENT8, OSSL_PARAM_UNSIGNED_INTEGER,
2576 get_rsa_payload_c8 },
2577 { GET, -1, -1, -1, 0, NULL, NULL,
2578 OSSL_PKEY_PARAM_RSA_COEFFICIENT9, OSSL_PARAM_UNSIGNED_INTEGER,
2579 get_rsa_payload_c9 },
2580
2581 /* EC */
2582 { GET, -1, -1, -1, 0, NULL, NULL,
2583 OSSL_PKEY_PARAM_EC_DECODED_FROM_EXPLICIT_PARAMS, OSSL_PARAM_INTEGER,
2584 get_ec_decoded_from_explicit_params },
2585 };
2586
2587 static const struct translation_st *
lookup_translation(struct translation_st * tmpl,const struct translation_st * translations,size_t translations_num)2588 lookup_translation(struct translation_st *tmpl,
2589 const struct translation_st *translations,
2590 size_t translations_num)
2591 {
2592 size_t i;
2593
2594 for (i = 0; i < translations_num; i++) {
2595 const struct translation_st *item = &translations[i];
2596
2597 /*
2598 * Sanity check the translation table item.
2599 *
2600 * 1. Either both keytypes are -1, or neither of them are.
2601 * 2. TBA...
2602 */
2603 if (!ossl_assert((item->keytype1 == -1) == (item->keytype2 == -1)))
2604 continue;
2605
2606
2607 /*
2608 * Base search criteria: check that the optype and keytypes match,
2609 * if relevant. All callers must synthesise these bits somehow.
2610 */
2611 if (item->optype != -1 && (tmpl->optype & item->optype) == 0)
2612 continue;
2613 /*
2614 * This expression is stunningly simple thanks to the sanity check
2615 * above.
2616 */
2617 if (item->keytype1 != -1
2618 && tmpl->keytype1 != item->keytype1
2619 && tmpl->keytype2 != item->keytype2)
2620 continue;
2621
2622 /*
2623 * Done with the base search criteria, now we check the criteria for
2624 * the individual types of translations:
2625 * ctrl->params, ctrl_str->params, and params->ctrl
2626 */
2627 if (tmpl->ctrl_num != 0) {
2628 if (tmpl->ctrl_num != item->ctrl_num)
2629 continue;
2630 } else if (tmpl->ctrl_str != NULL) {
2631 const char *ctrl_str = NULL;
2632 const char *ctrl_hexstr = NULL;
2633
2634 /*
2635 * Search criteria that originates from a ctrl_str is only used
2636 * for setting, never for getting. Therefore, we only look at
2637 * the setter items.
2638 */
2639 if (item->action_type != NONE
2640 && item->action_type != SET)
2641 continue;
2642 /*
2643 * At least one of the ctrl cmd names must be match the ctrl
2644 * cmd name in the template.
2645 */
2646 if (item->ctrl_str != NULL
2647 && OPENSSL_strcasecmp(tmpl->ctrl_str, item->ctrl_str) == 0)
2648 ctrl_str = tmpl->ctrl_str;
2649 else if (item->ctrl_hexstr != NULL
2650 && OPENSSL_strcasecmp(tmpl->ctrl_hexstr,
2651 item->ctrl_hexstr) == 0)
2652 ctrl_hexstr = tmpl->ctrl_hexstr;
2653 else
2654 continue;
2655
2656 /* Modify the template to signal which string matched */
2657 tmpl->ctrl_str = ctrl_str;
2658 tmpl->ctrl_hexstr = ctrl_hexstr;
2659 } else if (tmpl->param_key != NULL) {
2660 /*
2661 * Search criteria that originates from an OSSL_PARAM setter or
2662 * getter.
2663 *
2664 * Ctrls were fundamentally bidirectional, with only the ctrl
2665 * command macro name implying direction (if you're lucky).
2666 * A few ctrl commands were even taking advantage of the
2667 * bidirectional nature, making the direction depend in the
2668 * value of the numeric argument.
2669 *
2670 * OSSL_PARAM functions are fundamentally different, in that
2671 * setters and getters are separated, so the data direction is
2672 * implied by the function that's used. The same OSSL_PARAM
2673 * key name can therefore be used in both directions. We must
2674 * therefore take the action type into account in this case.
2675 */
2676 if ((item->action_type != NONE
2677 && tmpl->action_type != item->action_type)
2678 || (item->param_key != NULL
2679 && OPENSSL_strcasecmp(tmpl->param_key,
2680 item->param_key) != 0))
2681 continue;
2682 } else {
2683 return NULL;
2684 }
2685
2686 return item;
2687 }
2688
2689 return NULL;
2690 }
2691
2692 static const struct translation_st *
lookup_evp_pkey_ctx_translation(struct translation_st * tmpl)2693 lookup_evp_pkey_ctx_translation(struct translation_st *tmpl)
2694 {
2695 return lookup_translation(tmpl, evp_pkey_ctx_translations,
2696 OSSL_NELEM(evp_pkey_ctx_translations));
2697 }
2698
2699 static const struct translation_st *
lookup_evp_pkey_translation(struct translation_st * tmpl)2700 lookup_evp_pkey_translation(struct translation_st *tmpl)
2701 {
2702 return lookup_translation(tmpl, evp_pkey_translations,
2703 OSSL_NELEM(evp_pkey_translations));
2704 }
2705
2706 /* This must ONLY be called for provider side operations */
evp_pkey_ctx_ctrl_to_param(EVP_PKEY_CTX * pctx,int keytype,int optype,int cmd,int p1,void * p2)2707 int evp_pkey_ctx_ctrl_to_param(EVP_PKEY_CTX *pctx,
2708 int keytype, int optype,
2709 int cmd, int p1, void *p2)
2710 {
2711 struct translation_ctx_st ctx = { 0, };
2712 struct translation_st tmpl = { 0, };
2713 const struct translation_st *translation = NULL;
2714 OSSL_PARAM params[2] = { OSSL_PARAM_END, OSSL_PARAM_END };
2715 int ret;
2716 fixup_args_fn *fixup = default_fixup_args;
2717
2718 if (keytype == -1)
2719 keytype = pctx->legacy_keytype;
2720 tmpl.ctrl_num = cmd;
2721 tmpl.keytype1 = tmpl.keytype2 = keytype;
2722 tmpl.optype = optype;
2723 translation = lookup_evp_pkey_ctx_translation(&tmpl);
2724
2725 if (translation == NULL) {
2726 ERR_raise(ERR_LIB_EVP, EVP_R_COMMAND_NOT_SUPPORTED);
2727 return -2;
2728 }
2729
2730 if (pctx->pmeth != NULL
2731 && pctx->pmeth->pkey_id != translation->keytype1
2732 && pctx->pmeth->pkey_id != translation->keytype2)
2733 return -1;
2734
2735 if (translation->fixup_args != NULL)
2736 fixup = translation->fixup_args;
2737 ctx.action_type = translation->action_type;
2738 ctx.ctrl_cmd = cmd;
2739 ctx.p1 = p1;
2740 ctx.p2 = p2;
2741 ctx.pctx = pctx;
2742 ctx.params = params;
2743
2744 ret = fixup(PRE_CTRL_TO_PARAMS, translation, &ctx);
2745
2746 if (ret > 0) {
2747 switch (ctx.action_type) {
2748 default:
2749 /* fixup_args is expected to make sure this is dead code */
2750 break;
2751 case GET:
2752 ret = evp_pkey_ctx_get_params_strict(pctx, ctx.params);
2753 break;
2754 case SET:
2755 ret = evp_pkey_ctx_set_params_strict(pctx, ctx.params);
2756 break;
2757 }
2758 }
2759
2760 /*
2761 * In POST, we pass the return value as p1, allowing the fixup_args
2762 * function to affect it by changing its value.
2763 */
2764 if (ret > 0) {
2765 ctx.p1 = ret;
2766 fixup(POST_CTRL_TO_PARAMS, translation, &ctx);
2767 ret = ctx.p1;
2768 }
2769
2770 cleanup_translation_ctx(POST_CTRL_TO_PARAMS, translation, &ctx);
2771
2772 return ret;
2773 }
2774
2775 /* This must ONLY be called for provider side operations */
evp_pkey_ctx_ctrl_str_to_param(EVP_PKEY_CTX * pctx,const char * name,const char * value)2776 int evp_pkey_ctx_ctrl_str_to_param(EVP_PKEY_CTX *pctx,
2777 const char *name, const char *value)
2778 {
2779 struct translation_ctx_st ctx = { 0, };
2780 struct translation_st tmpl = { 0, };
2781 const struct translation_st *translation = NULL;
2782 OSSL_PARAM params[2] = { OSSL_PARAM_END, OSSL_PARAM_END };
2783 int keytype = pctx->legacy_keytype;
2784 int optype = pctx->operation == 0 ? -1 : pctx->operation;
2785 int ret;
2786 fixup_args_fn *fixup = default_fixup_args;
2787
2788 tmpl.action_type = SET;
2789 tmpl.keytype1 = tmpl.keytype2 = keytype;
2790 tmpl.optype = optype;
2791 tmpl.ctrl_str = name;
2792 tmpl.ctrl_hexstr = name;
2793 translation = lookup_evp_pkey_ctx_translation(&tmpl);
2794
2795 if (translation != NULL) {
2796 if (translation->fixup_args != NULL)
2797 fixup = translation->fixup_args;
2798 ctx.action_type = translation->action_type;
2799 ctx.ishex = (tmpl.ctrl_hexstr != NULL);
2800 } else {
2801 /* String controls really only support setting */
2802 ctx.action_type = SET;
2803 }
2804 ctx.ctrl_str = name;
2805 ctx.p1 = (int)strlen(value);
2806 ctx.p2 = (char *)value;
2807 ctx.pctx = pctx;
2808 ctx.params = params;
2809
2810 ret = fixup(PRE_CTRL_STR_TO_PARAMS, translation, &ctx);
2811
2812 if (ret > 0) {
2813 switch (ctx.action_type) {
2814 default:
2815 /* fixup_args is expected to make sure this is dead code */
2816 break;
2817 case GET:
2818 /*
2819 * this is dead code, but must be present, or some compilers
2820 * will complain
2821 */
2822 break;
2823 case SET:
2824 ret = evp_pkey_ctx_set_params_strict(pctx, ctx.params);
2825 break;
2826 }
2827 }
2828
2829 if (ret > 0)
2830 ret = fixup(POST_CTRL_STR_TO_PARAMS, translation, &ctx);
2831
2832 cleanup_translation_ctx(CLEANUP_CTRL_STR_TO_PARAMS, translation, &ctx);
2833
2834 return ret;
2835 }
2836
2837 /* This must ONLY be called for legacy operations */
evp_pkey_ctx_setget_params_to_ctrl(EVP_PKEY_CTX * pctx,enum action action_type,OSSL_PARAM * params)2838 static int evp_pkey_ctx_setget_params_to_ctrl(EVP_PKEY_CTX *pctx,
2839 enum action action_type,
2840 OSSL_PARAM *params)
2841 {
2842 int keytype = pctx->legacy_keytype;
2843 int optype = pctx->operation == 0 ? -1 : pctx->operation;
2844
2845 for (; params != NULL && params->key != NULL; params++) {
2846 struct translation_ctx_st ctx = { 0, };
2847 struct translation_st tmpl = { 0, };
2848 const struct translation_st *translation = NULL;
2849 fixup_args_fn *fixup = default_fixup_args;
2850 int ret;
2851
2852 ctx.action_type = tmpl.action_type = action_type;
2853 tmpl.keytype1 = tmpl.keytype2 = keytype;
2854 tmpl.optype = optype;
2855 tmpl.param_key = params->key;
2856 translation = lookup_evp_pkey_ctx_translation(&tmpl);
2857
2858 if (translation != NULL) {
2859 if (translation->fixup_args != NULL)
2860 fixup = translation->fixup_args;
2861 ctx.ctrl_cmd = translation->ctrl_num;
2862 }
2863 ctx.pctx = pctx;
2864 ctx.params = params;
2865
2866 ret = fixup(PRE_PARAMS_TO_CTRL, translation, &ctx);
2867
2868 if (ret > 0 && ctx.action_type != NONE)
2869 ret = EVP_PKEY_CTX_ctrl(pctx, keytype, optype,
2870 ctx.ctrl_cmd, ctx.p1, ctx.p2);
2871
2872 /*
2873 * In POST, we pass the return value as p1, allowing the fixup_args
2874 * function to put it to good use, or maybe affect it.
2875 *
2876 * NOTE: even though EVP_PKEY_CTX_ctrl return value is documented
2877 * as return positive on Success and 0 or negative on falure. There
2878 * maybe parameters (e.g. ecdh_cofactor), which actually return 0
2879 * as success value. That is why we do POST_PARAMS_TO_CTRL for 0
2880 * value as well
2881 */
2882 if (ret >= 0) {
2883 ctx.p1 = ret;
2884 fixup(POST_PARAMS_TO_CTRL, translation, &ctx);
2885 ret = ctx.p1;
2886 }
2887
2888 cleanup_translation_ctx(CLEANUP_PARAMS_TO_CTRL, translation, &ctx);
2889
2890 if (ret <= 0)
2891 return 0;
2892 }
2893 return 1;
2894 }
2895
evp_pkey_ctx_set_params_to_ctrl(EVP_PKEY_CTX * ctx,const OSSL_PARAM * params)2896 int evp_pkey_ctx_set_params_to_ctrl(EVP_PKEY_CTX *ctx, const OSSL_PARAM *params)
2897 {
2898 return evp_pkey_ctx_setget_params_to_ctrl(ctx, SET, (OSSL_PARAM *)params);
2899 }
2900
evp_pkey_ctx_get_params_to_ctrl(EVP_PKEY_CTX * ctx,OSSL_PARAM * params)2901 int evp_pkey_ctx_get_params_to_ctrl(EVP_PKEY_CTX *ctx, OSSL_PARAM *params)
2902 {
2903 return evp_pkey_ctx_setget_params_to_ctrl(ctx, GET, params);
2904 }
2905
2906 /* This must ONLY be called for legacy EVP_PKEYs */
evp_pkey_setget_params_to_ctrl(const EVP_PKEY * pkey,enum action action_type,OSSL_PARAM * params)2907 static int evp_pkey_setget_params_to_ctrl(const EVP_PKEY *pkey,
2908 enum action action_type,
2909 OSSL_PARAM *params)
2910 {
2911 int ret = 1;
2912
2913 for (; params != NULL && params->key != NULL; params++) {
2914 struct translation_ctx_st ctx = { 0, };
2915 struct translation_st tmpl = { 0, };
2916 const struct translation_st *translation = NULL;
2917 fixup_args_fn *fixup = default_fixup_args;
2918
2919 tmpl.action_type = action_type;
2920 tmpl.param_key = params->key;
2921 translation = lookup_evp_pkey_translation(&tmpl);
2922
2923 if (translation != NULL) {
2924 if (translation->fixup_args != NULL)
2925 fixup = translation->fixup_args;
2926 ctx.action_type = translation->action_type;
2927 }
2928 ctx.p2 = (void *)pkey;
2929 ctx.params = params;
2930
2931 /*
2932 * EVP_PKEY doesn't have any ctrl function, so we rely completely
2933 * on fixup_args to do the whole work. Also, we currently only
2934 * support getting.
2935 */
2936 if (!ossl_assert(translation != NULL)
2937 || !ossl_assert(translation->action_type == GET)
2938 || !ossl_assert(translation->fixup_args != NULL)) {
2939 return -2;
2940 }
2941
2942 ret = fixup(PKEY, translation, &ctx);
2943
2944 cleanup_translation_ctx(PKEY, translation, &ctx);
2945 }
2946 return ret;
2947 }
2948
evp_pkey_get_params_to_ctrl(const EVP_PKEY * pkey,OSSL_PARAM * params)2949 int evp_pkey_get_params_to_ctrl(const EVP_PKEY *pkey, OSSL_PARAM *params)
2950 {
2951 return evp_pkey_setget_params_to_ctrl(pkey, GET, params);
2952 }
2953
