2 * Copyright 2006-2016 The OpenSSL Project Authors. All Rights Reserved.
4 * Licensed under the OpenSSL license (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
12 #include "internal/cryptlib.h"
13 #include <openssl/engine.h>
14 #include <openssl/evp.h>
15 #include <openssl/x509v3.h>
16 #include "internal/asn1_int.h"
17 #include "internal/evp_int.h"
18 #include "internal/numbers.h"
20 typedef int sk_cmp_fn_type(const char *const *a, const char *const *b);
22 static STACK_OF(EVP_PKEY_METHOD) *app_pkey_methods = NULL;
24 static const EVP_PKEY_METHOD *standard_methods[] = {
25 #ifndef OPENSSL_NO_RSA
31 #ifndef OPENSSL_NO_DSA
38 #ifndef OPENSSL_NO_CMAC
48 DECLARE_OBJ_BSEARCH_CMP_FN(const EVP_PKEY_METHOD *, const EVP_PKEY_METHOD *,
51 static int pmeth_cmp(const EVP_PKEY_METHOD *const *a,
52 const EVP_PKEY_METHOD *const *b)
54 return ((*a)->pkey_id - (*b)->pkey_id);
57 IMPLEMENT_OBJ_BSEARCH_CMP_FN(const EVP_PKEY_METHOD *, const EVP_PKEY_METHOD *,
60 const EVP_PKEY_METHOD *EVP_PKEY_meth_find(int type)
63 const EVP_PKEY_METHOD *t = &tmp, **ret;
65 if (app_pkey_methods) {
67 idx = sk_EVP_PKEY_METHOD_find(app_pkey_methods, &tmp);
69 return sk_EVP_PKEY_METHOD_value(app_pkey_methods, idx);
71 ret = OBJ_bsearch_pmeth(&t, standard_methods,
72 sizeof(standard_methods) /
73 sizeof(EVP_PKEY_METHOD *));
79 static EVP_PKEY_CTX *int_ctx_new(EVP_PKEY *pkey, ENGINE *e, int id)
82 const EVP_PKEY_METHOD *pmeth;
84 if (!pkey || !pkey->ameth)
86 id = pkey->ameth->pkey_id;
88 #ifndef OPENSSL_NO_ENGINE
89 if (pkey && pkey->engine)
91 /* Try to find an ENGINE which implements this method */
93 if (!ENGINE_init(e)) {
94 EVPerr(EVP_F_INT_CTX_NEW, ERR_R_ENGINE_LIB);
98 e = ENGINE_get_pkey_meth_engine(id);
101 * If an ENGINE handled this method look it up. Otherwise use internal
106 pmeth = ENGINE_get_pkey_meth(e, id);
109 pmeth = EVP_PKEY_meth_find(id);
112 EVPerr(EVP_F_INT_CTX_NEW, EVP_R_UNSUPPORTED_ALGORITHM);
116 ret = OPENSSL_zalloc(sizeof(*ret));
118 #ifndef OPENSSL_NO_ENGINE
121 EVPerr(EVP_F_INT_CTX_NEW, ERR_R_MALLOC_FAILURE);
126 ret->operation = EVP_PKEY_OP_UNDEFINED;
129 EVP_PKEY_up_ref(pkey);
132 if (pmeth->init(ret) <= 0) {
133 EVP_PKEY_CTX_free(ret);
141 EVP_PKEY_METHOD *EVP_PKEY_meth_new(int id, int flags)
143 EVP_PKEY_METHOD *pmeth;
145 pmeth = OPENSSL_zalloc(sizeof(*pmeth));
150 pmeth->flags = flags | EVP_PKEY_FLAG_DYNAMIC;
154 void EVP_PKEY_meth_get0_info(int *ppkey_id, int *pflags,
155 const EVP_PKEY_METHOD *meth)
158 *ppkey_id = meth->pkey_id;
160 *pflags = meth->flags;
163 void EVP_PKEY_meth_copy(EVP_PKEY_METHOD *dst, const EVP_PKEY_METHOD *src)
166 dst->init = src->init;
167 dst->copy = src->copy;
168 dst->cleanup = src->cleanup;
170 dst->paramgen_init = src->paramgen_init;
171 dst->paramgen = src->paramgen;
173 dst->keygen_init = src->keygen_init;
174 dst->keygen = src->keygen;
176 dst->sign_init = src->sign_init;
177 dst->sign = src->sign;
179 dst->verify_init = src->verify_init;
180 dst->verify = src->verify;
182 dst->verify_recover_init = src->verify_recover_init;
183 dst->verify_recover = src->verify_recover;
185 dst->signctx_init = src->signctx_init;
186 dst->signctx = src->signctx;
188 dst->verifyctx_init = src->verifyctx_init;
189 dst->verifyctx = src->verifyctx;
191 dst->encrypt_init = src->encrypt_init;
192 dst->encrypt = src->encrypt;
194 dst->decrypt_init = src->decrypt_init;
195 dst->decrypt = src->decrypt;
197 dst->derive_init = src->derive_init;
198 dst->derive = src->derive;
200 dst->ctrl = src->ctrl;
201 dst->ctrl_str = src->ctrl_str;
204 void EVP_PKEY_meth_free(EVP_PKEY_METHOD *pmeth)
206 if (pmeth && (pmeth->flags & EVP_PKEY_FLAG_DYNAMIC))
210 EVP_PKEY_CTX *EVP_PKEY_CTX_new(EVP_PKEY *pkey, ENGINE *e)
212 return int_ctx_new(pkey, e, -1);
215 EVP_PKEY_CTX *EVP_PKEY_CTX_new_id(int id, ENGINE *e)
217 return int_ctx_new(NULL, e, id);
220 EVP_PKEY_CTX *EVP_PKEY_CTX_dup(EVP_PKEY_CTX *pctx)
223 if (!pctx->pmeth || !pctx->pmeth->copy)
225 #ifndef OPENSSL_NO_ENGINE
226 /* Make sure it's safe to copy a pkey context using an ENGINE */
227 if (pctx->engine && !ENGINE_init(pctx->engine)) {
228 EVPerr(EVP_F_EVP_PKEY_CTX_DUP, ERR_R_ENGINE_LIB);
232 rctx = OPENSSL_malloc(sizeof(*rctx));
236 rctx->pmeth = pctx->pmeth;
237 #ifndef OPENSSL_NO_ENGINE
238 rctx->engine = pctx->engine;
242 EVP_PKEY_up_ref(pctx->pkey);
244 rctx->pkey = pctx->pkey;
247 EVP_PKEY_up_ref(pctx->peerkey);
249 rctx->peerkey = pctx->peerkey;
252 rctx->app_data = NULL;
253 rctx->operation = pctx->operation;
255 if (pctx->pmeth->copy(rctx, pctx) > 0)
258 EVP_PKEY_CTX_free(rctx);
263 int EVP_PKEY_meth_add0(const EVP_PKEY_METHOD *pmeth)
265 if (app_pkey_methods == NULL) {
266 app_pkey_methods = sk_EVP_PKEY_METHOD_new(pmeth_cmp);
267 if (app_pkey_methods == NULL)
270 if (!sk_EVP_PKEY_METHOD_push(app_pkey_methods, pmeth))
272 sk_EVP_PKEY_METHOD_sort(app_pkey_methods);
276 void EVP_PKEY_CTX_free(EVP_PKEY_CTX *ctx)
280 if (ctx->pmeth && ctx->pmeth->cleanup)
281 ctx->pmeth->cleanup(ctx);
282 EVP_PKEY_free(ctx->pkey);
283 EVP_PKEY_free(ctx->peerkey);
284 #ifndef OPENSSL_NO_ENGINE
285 ENGINE_finish(ctx->engine);
290 int EVP_PKEY_CTX_ctrl(EVP_PKEY_CTX *ctx, int keytype, int optype,
291 int cmd, int p1, void *p2)
294 if (!ctx || !ctx->pmeth || !ctx->pmeth->ctrl) {
295 EVPerr(EVP_F_EVP_PKEY_CTX_CTRL, EVP_R_COMMAND_NOT_SUPPORTED);
298 if ((keytype != -1) && (ctx->pmeth->pkey_id != keytype))
301 if (ctx->operation == EVP_PKEY_OP_UNDEFINED) {
302 EVPerr(EVP_F_EVP_PKEY_CTX_CTRL, EVP_R_NO_OPERATION_SET);
306 if ((optype != -1) && !(ctx->operation & optype)) {
307 EVPerr(EVP_F_EVP_PKEY_CTX_CTRL, EVP_R_INVALID_OPERATION);
311 ret = ctx->pmeth->ctrl(ctx, cmd, p1, p2);
314 EVPerr(EVP_F_EVP_PKEY_CTX_CTRL, EVP_R_COMMAND_NOT_SUPPORTED);
320 int EVP_PKEY_CTX_ctrl_str(EVP_PKEY_CTX *ctx,
321 const char *name, const char *value)
323 if (!ctx || !ctx->pmeth || !ctx->pmeth->ctrl_str) {
324 EVPerr(EVP_F_EVP_PKEY_CTX_CTRL_STR, EVP_R_COMMAND_NOT_SUPPORTED);
327 if (strcmp(name, "digest") == 0) {
329 if (value == NULL || (md = EVP_get_digestbyname(value)) == NULL) {
330 EVPerr(EVP_F_EVP_PKEY_CTX_CTRL_STR, EVP_R_INVALID_DIGEST);
333 return EVP_PKEY_CTX_set_signature_md(ctx, md);
335 return ctx->pmeth->ctrl_str(ctx, name, value);
338 /* Utility functions to send a string of hex string to a ctrl */
340 int EVP_PKEY_CTX_str2ctrl(EVP_PKEY_CTX *ctx, int cmd, const char *str)
347 return ctx->pmeth->ctrl(ctx, cmd, len, (void *)str);
350 int EVP_PKEY_CTX_hex2ctrl(EVP_PKEY_CTX *ctx, int cmd, const char *hex)
356 bin = OPENSSL_hexstr2buf(hex, &binlen);
359 if (binlen <= INT_MAX)
360 rv = ctx->pmeth->ctrl(ctx, cmd, binlen, bin);
365 int EVP_PKEY_CTX_get_operation(EVP_PKEY_CTX *ctx)
367 return ctx->operation;
370 void EVP_PKEY_CTX_set0_keygen_info(EVP_PKEY_CTX *ctx, int *dat, int datlen)
372 ctx->keygen_info = dat;
373 ctx->keygen_info_count = datlen;
376 void EVP_PKEY_CTX_set_data(EVP_PKEY_CTX *ctx, void *data)
381 void *EVP_PKEY_CTX_get_data(EVP_PKEY_CTX *ctx)
386 EVP_PKEY *EVP_PKEY_CTX_get0_pkey(EVP_PKEY_CTX *ctx)
391 EVP_PKEY *EVP_PKEY_CTX_get0_peerkey(EVP_PKEY_CTX *ctx)
396 void EVP_PKEY_CTX_set_app_data(EVP_PKEY_CTX *ctx, void *data)
398 ctx->app_data = data;
401 void *EVP_PKEY_CTX_get_app_data(EVP_PKEY_CTX *ctx)
403 return ctx->app_data;
406 void EVP_PKEY_meth_set_init(EVP_PKEY_METHOD *pmeth,
407 int (*init) (EVP_PKEY_CTX *ctx))
412 void EVP_PKEY_meth_set_copy(EVP_PKEY_METHOD *pmeth,
413 int (*copy) (EVP_PKEY_CTX *dst,
419 void EVP_PKEY_meth_set_cleanup(EVP_PKEY_METHOD *pmeth,
420 void (*cleanup) (EVP_PKEY_CTX *ctx))
422 pmeth->cleanup = cleanup;
425 void EVP_PKEY_meth_set_paramgen(EVP_PKEY_METHOD *pmeth,
426 int (*paramgen_init) (EVP_PKEY_CTX *ctx),
427 int (*paramgen) (EVP_PKEY_CTX *ctx,
430 pmeth->paramgen_init = paramgen_init;
431 pmeth->paramgen = paramgen;
434 void EVP_PKEY_meth_set_keygen(EVP_PKEY_METHOD *pmeth,
435 int (*keygen_init) (EVP_PKEY_CTX *ctx),
436 int (*keygen) (EVP_PKEY_CTX *ctx,
439 pmeth->keygen_init = keygen_init;
440 pmeth->keygen = keygen;
443 void EVP_PKEY_meth_set_sign(EVP_PKEY_METHOD *pmeth,
444 int (*sign_init) (EVP_PKEY_CTX *ctx),
445 int (*sign) (EVP_PKEY_CTX *ctx,
446 unsigned char *sig, size_t *siglen,
447 const unsigned char *tbs,
450 pmeth->sign_init = sign_init;
454 void EVP_PKEY_meth_set_verify(EVP_PKEY_METHOD *pmeth,
455 int (*verify_init) (EVP_PKEY_CTX *ctx),
456 int (*verify) (EVP_PKEY_CTX *ctx,
457 const unsigned char *sig,
459 const unsigned char *tbs,
462 pmeth->verify_init = verify_init;
463 pmeth->verify = verify;
466 void EVP_PKEY_meth_set_verify_recover(EVP_PKEY_METHOD *pmeth,
467 int (*verify_recover_init) (EVP_PKEY_CTX
469 int (*verify_recover) (EVP_PKEY_CTX
478 pmeth->verify_recover_init = verify_recover_init;
479 pmeth->verify_recover = verify_recover;
482 void EVP_PKEY_meth_set_signctx(EVP_PKEY_METHOD *pmeth,
483 int (*signctx_init) (EVP_PKEY_CTX *ctx,
485 int (*signctx) (EVP_PKEY_CTX *ctx,
490 pmeth->signctx_init = signctx_init;
491 pmeth->signctx = signctx;
494 void EVP_PKEY_meth_set_verifyctx(EVP_PKEY_METHOD *pmeth,
495 int (*verifyctx_init) (EVP_PKEY_CTX *ctx,
497 int (*verifyctx) (EVP_PKEY_CTX *ctx,
498 const unsigned char *sig,
502 pmeth->verifyctx_init = verifyctx_init;
503 pmeth->verifyctx = verifyctx;
506 void EVP_PKEY_meth_set_encrypt(EVP_PKEY_METHOD *pmeth,
507 int (*encrypt_init) (EVP_PKEY_CTX *ctx),
508 int (*encryptfn) (EVP_PKEY_CTX *ctx,
511 const unsigned char *in,
514 pmeth->encrypt_init = encrypt_init;
515 pmeth->encrypt = encryptfn;
518 void EVP_PKEY_meth_set_decrypt(EVP_PKEY_METHOD *pmeth,
519 int (*decrypt_init) (EVP_PKEY_CTX *ctx),
520 int (*decrypt) (EVP_PKEY_CTX *ctx,
523 const unsigned char *in,
526 pmeth->decrypt_init = decrypt_init;
527 pmeth->decrypt = decrypt;
530 void EVP_PKEY_meth_set_derive(EVP_PKEY_METHOD *pmeth,
531 int (*derive_init) (EVP_PKEY_CTX *ctx),
532 int (*derive) (EVP_PKEY_CTX *ctx,
536 pmeth->derive_init = derive_init;
537 pmeth->derive = derive;
540 void EVP_PKEY_meth_set_ctrl(EVP_PKEY_METHOD *pmeth,
541 int (*ctrl) (EVP_PKEY_CTX *ctx, int type, int p1,
543 int (*ctrl_str) (EVP_PKEY_CTX *ctx,
548 pmeth->ctrl_str = ctrl_str;
551 void EVP_PKEY_meth_get_init(EVP_PKEY_METHOD *pmeth,
552 int (**pinit) (EVP_PKEY_CTX *ctx))
554 *pinit = pmeth->init;
557 void EVP_PKEY_meth_get_copy(EVP_PKEY_METHOD *pmeth,
558 int (**pcopy) (EVP_PKEY_CTX *dst,
561 *pcopy = pmeth->copy;
564 void EVP_PKEY_meth_get_cleanup(EVP_PKEY_METHOD *pmeth,
565 void (**pcleanup) (EVP_PKEY_CTX *ctx))
567 *pcleanup = pmeth->cleanup;
570 void EVP_PKEY_meth_get_paramgen(EVP_PKEY_METHOD *pmeth,
571 int (**pparamgen_init) (EVP_PKEY_CTX *ctx),
572 int (**pparamgen) (EVP_PKEY_CTX *ctx,
576 *pparamgen_init = pmeth->paramgen_init;
578 *pparamgen = pmeth->paramgen;
581 void EVP_PKEY_meth_get_keygen(EVP_PKEY_METHOD *pmeth,
582 int (**pkeygen_init) (EVP_PKEY_CTX *ctx),
583 int (**pkeygen) (EVP_PKEY_CTX *ctx,
587 *pkeygen_init = pmeth->keygen_init;
589 *pkeygen = pmeth->keygen;
592 void EVP_PKEY_meth_get_sign(EVP_PKEY_METHOD *pmeth,
593 int (**psign_init) (EVP_PKEY_CTX *ctx),
594 int (**psign) (EVP_PKEY_CTX *ctx,
595 unsigned char *sig, size_t *siglen,
596 const unsigned char *tbs,
600 *psign_init = pmeth->sign_init;
602 *psign = pmeth->sign;
605 void EVP_PKEY_meth_get_verify(EVP_PKEY_METHOD *pmeth,
606 int (**pverify_init) (EVP_PKEY_CTX *ctx),
607 int (**pverify) (EVP_PKEY_CTX *ctx,
608 const unsigned char *sig,
610 const unsigned char *tbs,
614 *pverify_init = pmeth->verify_init;
616 *pverify = pmeth->verify;
619 void EVP_PKEY_meth_get_verify_recover(EVP_PKEY_METHOD *pmeth,
620 int (**pverify_recover_init) (EVP_PKEY_CTX
622 int (**pverify_recover) (EVP_PKEY_CTX
631 if (pverify_recover_init)
632 *pverify_recover_init = pmeth->verify_recover_init;
634 *pverify_recover = pmeth->verify_recover;
637 void EVP_PKEY_meth_get_signctx(EVP_PKEY_METHOD *pmeth,
638 int (**psignctx_init) (EVP_PKEY_CTX *ctx,
640 int (**psignctx) (EVP_PKEY_CTX *ctx,
646 *psignctx_init = pmeth->signctx_init;
648 *psignctx = pmeth->signctx;
651 void EVP_PKEY_meth_get_verifyctx(EVP_PKEY_METHOD *pmeth,
652 int (**pverifyctx_init) (EVP_PKEY_CTX *ctx,
654 int (**pverifyctx) (EVP_PKEY_CTX *ctx,
655 const unsigned char *sig,
660 *pverifyctx_init = pmeth->verifyctx_init;
662 *pverifyctx = pmeth->verifyctx;
665 void EVP_PKEY_meth_get_encrypt(EVP_PKEY_METHOD *pmeth,
666 int (**pencrypt_init) (EVP_PKEY_CTX *ctx),
667 int (**pencryptfn) (EVP_PKEY_CTX *ctx,
670 const unsigned char *in,
674 *pencrypt_init = pmeth->encrypt_init;
676 *pencryptfn = pmeth->encrypt;
679 void EVP_PKEY_meth_get_decrypt(EVP_PKEY_METHOD *pmeth,
680 int (**pdecrypt_init) (EVP_PKEY_CTX *ctx),
681 int (**pdecrypt) (EVP_PKEY_CTX *ctx,
684 const unsigned char *in,
688 *pdecrypt_init = pmeth->decrypt_init;
690 *pdecrypt = pmeth->decrypt;
693 void EVP_PKEY_meth_get_derive(EVP_PKEY_METHOD *pmeth,
694 int (**pderive_init) (EVP_PKEY_CTX *ctx),
695 int (**pderive) (EVP_PKEY_CTX *ctx,
700 *pderive_init = pmeth->derive_init;
702 *pderive = pmeth->derive;
705 void EVP_PKEY_meth_get_ctrl(EVP_PKEY_METHOD *pmeth,
706 int (**pctrl) (EVP_PKEY_CTX *ctx, int type, int p1,
708 int (**pctrl_str) (EVP_PKEY_CTX *ctx,
713 *pctrl = pmeth->ctrl;
715 *pctrl_str = pmeth->ctrl_str;