]> git.ipfire.org Git - thirdparty/openssl.git/blame - crypto/evp/pmeth_lib.c
projects / thirdparty / openssl.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Various RAND improvements
[thirdparty/openssl.git] / crypto / evp / pmeth_lib.c
CommitLineData
0f113f3e 1/*
3f5616d7 2 * Copyright 2006-2017 The OpenSSL Project Authors. All Rights Reserved.
0b6f3c66 3 *
62867571
RS		 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
0b6f3c66
DSH		 8 */
9
10#include <stdio.h>
11#include <stdlib.h>
b39fc560 12#include "internal/cryptlib.h"
3c27208f 13#include <openssl/engine.h>
33bed28b 14#include <openssl/evp.h>
99119000 15#include <openssl/x509v3.h>
5fe736e5 16#include "internal/asn1_int.h"
27af42f9 17#include "internal/evp_int.h"
99119000 18#include "internal/numbers.h"
0b6f3c66 19
0f113f3e 20typedef int sk_cmp_fn_type(const char *const *a, const char *const *b);
5ce278a7 21
df2ee0e2 22static STACK_OF(EVP_PKEY_METHOD) *app_pkey_methods = NULL;
0b6f3c66 23
0f113f3e 24static const EVP_PKEY_METHOD *standard_methods[] = {
d4f0339c 25#ifndef OPENSSL_NO_RSA
0f113f3e 26 &rsa_pkey_meth,
d4f0339c
DSH		 27#endif
28#ifndef OPENSSL_NO_DH
0f113f3e 29 &dh_pkey_meth,
d4f0339c
DSH		 30#endif
31#ifndef OPENSSL_NO_DSA
0f113f3e 32 &dsa_pkey_meth,
d4f0339c 33#endif
ef236ec3 34#ifndef OPENSSL_NO_EC
0f113f3e 35 &ec_pkey_meth,
ef236ec3 36#endif
0f113f3e 37 &hmac_pkey_meth,
b4a3aeeb 38#ifndef OPENSSL_NO_CMAC
0f113f3e 39 &cmac_pkey_meth,
b4a3aeeb 40#endif
6577e008
DSH		 41#ifndef OPENSSL_NO_RSA
42 &rsa_pss_pkey_meth,
43#endif
afb14cda 44#ifndef OPENSSL_NO_DH
1eff3485 45 &dhx_pkey_meth,
afb14cda 46#endif
aacfb134 47 &tls1_prf_pkey_meth,
262bd85f
DSH		 48#ifndef OPENSSL_NO_EC
49 &ecx25519_pkey_meth,
50#endif
52ad5b60
TS		 51 &hkdf_pkey_meth,
52#ifndef OPENSSL_NO_POLY1305
53 &poly1305_pkey_meth,
54#endif
3f5616d7
TS		 55#ifndef OPENSSL_NO_SIPHASH
56 &siphash_pkey_meth,
57#endif
42a3008a
DSH		 58#ifndef OPENSSL_NO_EC
59 &ed25519_pkey_meth,
60#endif
0f113f3e 61};
0b6f3c66 62
606f6c47 63DECLARE_OBJ_BSEARCH_CMP_FN(const EVP_PKEY_METHOD *, const EVP_PKEY_METHOD *,
0f113f3e 64 pmeth);
babb3798 65
0f113f3e
MC		 66static int pmeth_cmp(const EVP_PKEY_METHOD *const *a,
67 const EVP_PKEY_METHOD *const *b)
68{
69 return ((*a)->pkey_id - (*b)->pkey_id);
70}
0b6f3c66 71
606f6c47 72IMPLEMENT_OBJ_BSEARCH_CMP_FN(const EVP_PKEY_METHOD *, const EVP_PKEY_METHOD *,
0f113f3e 73 pmeth);
babb3798 74
c9777d26 75const EVP_PKEY_METHOD *EVP_PKEY_meth_find(int type)
0f113f3e
MC		 76{
77 EVP_PKEY_METHOD tmp;
78 const EVP_PKEY_METHOD *t = &tmp, **ret;
79 tmp.pkey_id = type;
80 if (app_pkey_methods) {
81 int idx;
82 idx = sk_EVP_PKEY_METHOD_find(app_pkey_methods, &tmp);
83 if (idx >= 0)
84 return sk_EVP_PKEY_METHOD_value(app_pkey_methods, idx);
85 }
86 ret = OBJ_bsearch_pmeth(&t, standard_methods,
87 sizeof(standard_methods) /
88 sizeof(EVP_PKEY_METHOD *));
89 if (!ret || !*ret)
90 return NULL;
91 return *ret;
92}
0b6f3c66 93
f5cda4cb 94static EVP_PKEY_CTX *int_ctx_new(EVP_PKEY *pkey, ENGINE *e, int id)
0f113f3e
MC		 95{
96 EVP_PKEY_CTX *ret;
97 const EVP_PKEY_METHOD *pmeth;
98 if (id == -1) {
99 if (!pkey || !pkey->ameth)
100 return NULL;
101 id = pkey->ameth->pkey_id;
102 }
a63bf2c5 103#ifndef OPENSSL_NO_ENGINE
0f113f3e
MC		 104 if (pkey && pkey->engine)
105 e = pkey->engine;
106 /* Try to find an ENGINE which implements this method */
107 if (e) {
108 if (!ENGINE_init(e)) {
109 EVPerr(EVP_F_INT_CTX_NEW, ERR_R_ENGINE_LIB);
110 return NULL;
111 }
112 } else
113 e = ENGINE_get_pkey_meth_engine(id);
114
115 /*
0d4fb843 116 * If an ENGINE handled this method look it up. Otherwise use internal
0f113f3e
MC		 117 * tables.
118 */
119
120 if (e)
121 pmeth = ENGINE_get_pkey_meth(e, id);
122 else
a63bf2c5 123#endif
0f113f3e 124 pmeth = EVP_PKEY_meth_find(id);
c9777d26 125
0f113f3e
MC		 126 if (pmeth == NULL) {
127 EVPerr(EVP_F_INT_CTX_NEW, EVP_R_UNSUPPORTED_ALGORITHM);
128 return NULL;
129 }
c9777d26 130
64b25758 131 ret = OPENSSL_zalloc(sizeof(*ret));
90945fa3 132 if (ret == NULL) {
a63bf2c5 133#ifndef OPENSSL_NO_ENGINE
7c96dbcd 134 ENGINE_finish(e);
a63bf2c5 135#endif
0f113f3e
MC		 136 EVPerr(EVP_F_INT_CTX_NEW, ERR_R_MALLOC_FAILURE);
137 return NULL;
138 }
139 ret->engine = e;
140 ret->pmeth = pmeth;
141 ret->operation = EVP_PKEY_OP_UNDEFINED;
142 ret->pkey = pkey;
0f113f3e 143 if (pkey)
03273d61 144 EVP_PKEY_up_ref(pkey);
0f113f3e
MC		 145
146 if (pmeth->init) {
147 if (pmeth->init(ret) <= 0) {
83b4049a 148 ret->pmeth = NULL;
0f113f3e
MC		 149 EVP_PKEY_CTX_free(ret);
150 return NULL;
151 }
152 }
153
154 return ret;
155}
156
157EVP_PKEY_METHOD *EVP_PKEY_meth_new(int id, int flags)
158{
159 EVP_PKEY_METHOD *pmeth;
b4faea50 160
b51bce94 161 pmeth = OPENSSL_zalloc(sizeof(*pmeth));
90945fa3 162 if (pmeth == NULL)
0f113f3e
MC		 163 return NULL;
164
0f113f3e
MC		 165 pmeth->pkey_id = id;
166 pmeth->flags = flags | EVP_PKEY_FLAG_DYNAMIC;
0f113f3e
MC		 167 return pmeth;
168}
ba30bad5 169
f830c68f 170void EVP_PKEY_meth_get0_info(int *ppkey_id, int *pflags,
0f113f3e
MC		 171 const EVP_PKEY_METHOD *meth)
172{
173 if (ppkey_id)
174 *ppkey_id = meth->pkey_id;
175 if (pflags)
176 *pflags = meth->flags;
177}
f830c68f
DSH		 178
179void EVP_PKEY_meth_copy(EVP_PKEY_METHOD *dst, const EVP_PKEY_METHOD *src)
0f113f3e 180{
f830c68f 181
0f113f3e
MC		 182 dst->init = src->init;
183 dst->copy = src->copy;
184 dst->cleanup = src->cleanup;
f830c68f 185
0f113f3e
MC		 186 dst->paramgen_init = src->paramgen_init;
187 dst->paramgen = src->paramgen;
f830c68f 188
0f113f3e
MC		 189 dst->keygen_init = src->keygen_init;
190 dst->keygen = src->keygen;
f830c68f 191
0f113f3e
MC		 192 dst->sign_init = src->sign_init;
193 dst->sign = src->sign;
f830c68f 194
0f113f3e
MC		 195 dst->verify_init = src->verify_init;
196 dst->verify = src->verify;
f830c68f 197
0f113f3e
MC		 198 dst->verify_recover_init = src->verify_recover_init;
199 dst->verify_recover = src->verify_recover;
f830c68f 200
0f113f3e
MC		 201 dst->signctx_init = src->signctx_init;
202 dst->signctx = src->signctx;
f830c68f 203
0f113f3e
MC		 204 dst->verifyctx_init = src->verifyctx_init;
205 dst->verifyctx = src->verifyctx;
f830c68f 206
0f113f3e
MC		 207 dst->encrypt_init = src->encrypt_init;
208 dst->encrypt = src->encrypt;
f830c68f 209
0f113f3e
MC		 210 dst->decrypt_init = src->decrypt_init;
211 dst->decrypt = src->decrypt;
f830c68f 212
0f113f3e
MC		 213 dst->derive_init = src->derive_init;
214 dst->derive = src->derive;
f830c68f 215
0f113f3e
MC		 216 dst->ctrl = src->ctrl;
217 dst->ctrl_str = src->ctrl_str;
218}
f830c68f 219
ba30bad5 220void EVP_PKEY_meth_free(EVP_PKEY_METHOD *pmeth)
0f113f3e
MC		 221{
222 if (pmeth && (pmeth->flags & EVP_PKEY_FLAG_DYNAMIC))
223 OPENSSL_free(pmeth);
224}
ba30bad5 225
f5cda4cb 226EVP_PKEY_CTX *EVP_PKEY_CTX_new(EVP_PKEY *pkey, ENGINE *e)
0f113f3e
MC		 227{
228 return int_ctx_new(pkey, e, -1);
229}
f5cda4cb
DSH		 230
231EVP_PKEY_CTX *EVP_PKEY_CTX_new_id(int id, ENGINE *e)
0f113f3e
MC		 232{
233 return int_ctx_new(NULL, e, id);
234}
f5cda4cb 235
8bdcef40 236EVP_PKEY_CTX *EVP_PKEY_CTX_dup(EVP_PKEY_CTX *pctx)
0f113f3e
MC		 237{
238 EVP_PKEY_CTX *rctx;
239 if (!pctx->pmeth || !pctx->pmeth->copy)
240 return NULL;
c9777d26 241#ifndef OPENSSL_NO_ENGINE
0f113f3e
MC		 242 /* Make sure it's safe to copy a pkey context using an ENGINE */
243 if (pctx->engine && !ENGINE_init(pctx->engine)) {
244 EVPerr(EVP_F_EVP_PKEY_CTX_DUP, ERR_R_ENGINE_LIB);
245 return 0;
246 }
c9777d26 247#endif
b4faea50 248 rctx = OPENSSL_malloc(sizeof(*rctx));
90945fa3 249 if (rctx == NULL)
0f113f3e 250 return NULL;
8bdcef40 251
0f113f3e 252 rctx->pmeth = pctx->pmeth;
c9777d26 253#ifndef OPENSSL_NO_ENGINE
0f113f3e 254 rctx->engine = pctx->engine;
c9777d26 255#endif
8bdcef40 256
0f113f3e 257 if (pctx->pkey)
03273d61 258 EVP_PKEY_up_ref(pctx->pkey);
944f8580 259
0f113f3e 260 rctx->pkey = pctx->pkey;
8bdcef40 261
0f113f3e 262 if (pctx->peerkey)
03273d61 263 EVP_PKEY_up_ref(pctx->peerkey);
944f8580 264
0f113f3e 265 rctx->peerkey = pctx->peerkey;
8bdcef40 266
0f113f3e
MC		 267 rctx->data = NULL;
268 rctx->app_data = NULL;
269 rctx->operation = pctx->operation;
8bdcef40 270
0f113f3e
MC		 271 if (pctx->pmeth->copy(rctx, pctx) > 0)
272 return rctx;
8bdcef40 273
83b4049a 274 rctx->pmeth = NULL;
0f113f3e
MC		 275 EVP_PKEY_CTX_free(rctx);
276 return NULL;
8bdcef40 277
0f113f3e 278}
8bdcef40 279
ba30bad5 280int EVP_PKEY_meth_add0(const EVP_PKEY_METHOD *pmeth)
0f113f3e
MC		 281{
282 if (app_pkey_methods == NULL) {
283 app_pkey_methods = sk_EVP_PKEY_METHOD_new(pmeth_cmp);
90945fa3 284 if (app_pkey_methods == NULL)
0f113f3e
MC		 285 return 0;
286 }
287 if (!sk_EVP_PKEY_METHOD_push(app_pkey_methods, pmeth))
288 return 0;
289 sk_EVP_PKEY_METHOD_sort(app_pkey_methods);
290 return 1;
291}
ba30bad5 292
48ed9c23
DSH		 293size_t EVP_PKEY_meth_get_count(void)
294{
295 size_t rv = OSSL_NELEM(standard_methods);
296
297 if (app_pkey_methods)
298 rv += sk_EVP_PKEY_METHOD_num(app_pkey_methods);
299 return rv;
300}
301
302const EVP_PKEY_METHOD *EVP_PKEY_meth_get0(size_t idx)
303{
304 if (idx < OSSL_NELEM(standard_methods))
305 return standard_methods[idx];
306 if (app_pkey_methods == NULL)
307 return NULL;
308 idx -= OSSL_NELEM(standard_methods);
309 if (idx >= (size_t)sk_EVP_PKEY_METHOD_num(app_pkey_methods))
310 return NULL;
311 return sk_EVP_PKEY_METHOD_value(app_pkey_methods, idx);
312}
313
5da98aa6 314void EVP_PKEY_CTX_free(EVP_PKEY_CTX *ctx)
0f113f3e
MC		 315{
316 if (ctx == NULL)
317 return;
318 if (ctx->pmeth && ctx->pmeth->cleanup)
319 ctx->pmeth->cleanup(ctx);
c5ba2d99
RS		 320 EVP_PKEY_free(ctx->pkey);
321 EVP_PKEY_free(ctx->peerkey);
c9777d26 322#ifndef OPENSSL_NO_ENGINE
7c96dbcd 323 ENGINE_finish(ctx->engine);
c9777d26 324#endif
0f113f3e
MC		 325 OPENSSL_free(ctx);
326}
5da98aa6 327
0b6f3c66 328int EVP_PKEY_CTX_ctrl(EVP_PKEY_CTX *ctx, int keytype, int optype,
0f113f3e
MC		 329 int cmd, int p1, void *p2)
330{
331 int ret;
332 if (!ctx || !ctx->pmeth || !ctx->pmeth->ctrl) {
333 EVPerr(EVP_F_EVP_PKEY_CTX_CTRL, EVP_R_COMMAND_NOT_SUPPORTED);
334 return -2;
335 }
336 if ((keytype != -1) && (ctx->pmeth->pkey_id != keytype))
337 return -1;
338
339 if (ctx->operation == EVP_PKEY_OP_UNDEFINED) {
340 EVPerr(EVP_F_EVP_PKEY_CTX_CTRL, EVP_R_NO_OPERATION_SET);
341 return -1;
342 }
343
344 if ((optype != -1) && !(ctx->operation & optype)) {
345 EVPerr(EVP_F_EVP_PKEY_CTX_CTRL, EVP_R_INVALID_OPERATION);
346 return -1;
347 }
348
349 ret = ctx->pmeth->ctrl(ctx, cmd, p1, p2);
350
351 if (ret == -2)
352 EVPerr(EVP_F_EVP_PKEY_CTX_CTRL, EVP_R_COMMAND_NOT_SUPPORTED);
353
354 return ret;
355
356}
0b6f3c66 357
4a3dc3c0 358int EVP_PKEY_CTX_ctrl_str(EVP_PKEY_CTX *ctx,
0f113f3e
MC		 359 const char *name, const char *value)
360{
361 if (!ctx || !ctx->pmeth || !ctx->pmeth->ctrl_str) {
362 EVPerr(EVP_F_EVP_PKEY_CTX_CTRL_STR, EVP_R_COMMAND_NOT_SUPPORTED);
363 return -2;
364 }
410877ba
DSH		 365 if (strcmp(name, "digest") == 0)
366 return EVP_PKEY_CTX_md(ctx, EVP_PKEY_OP_TYPE_SIG, EVP_PKEY_CTRL_MD,
367 value);
0f113f3e
MC		 368 return ctx->pmeth->ctrl_str(ctx, name, value);
369}
f5cda4cb 370
99119000
DSH		 371/* Utility functions to send a string of hex string to a ctrl */
372
373int EVP_PKEY_CTX_str2ctrl(EVP_PKEY_CTX *ctx, int cmd, const char *str)
374{
375 size_t len;
376
377 len = strlen(str);
378 if (len > INT_MAX)
379 return -1;
380 return ctx->pmeth->ctrl(ctx, cmd, len, (void *)str);
381}
382
383int EVP_PKEY_CTX_hex2ctrl(EVP_PKEY_CTX *ctx, int cmd, const char *hex)
384{
385 unsigned char *bin;
386 long binlen;
387 int rv = -1;
388
14f051a0 389 bin = OPENSSL_hexstr2buf(hex, &binlen);
99119000
DSH		 390 if (bin == NULL)
391 return 0;
392 if (binlen <= INT_MAX)
393 rv = ctx->pmeth->ctrl(ctx, cmd, binlen, bin);
394 OPENSSL_free(bin);
395 return rv;
396}
52ad523c 397
410877ba
DSH		 398/* Pass a message digest to a ctrl */
399int EVP_PKEY_CTX_md(EVP_PKEY_CTX *ctx, int optype, int cmd, const char *md)
400{
401 const EVP_MD *m;
c82bafc5 402
410877ba
DSH		 403 if (md == NULL || (m = EVP_get_digestbyname(md)) == NULL) {
404 EVPerr(EVP_F_EVP_PKEY_CTX_MD, EVP_R_INVALID_DIGEST);
405 return 0;
406 }
407 return EVP_PKEY_CTX_ctrl(ctx, -1, optype, cmd, 0, (void *)m);
408}
99119000 409
b28dea4e 410int EVP_PKEY_CTX_get_operation(EVP_PKEY_CTX *ctx)
0f113f3e
MC		 411{
412 return ctx->operation;
413}
b28dea4e
DSH		 414
415void EVP_PKEY_CTX_set0_keygen_info(EVP_PKEY_CTX *ctx, int *dat, int datlen)
0f113f3e
MC		 416{
417 ctx->keygen_info = dat;
418 ctx->keygen_info_count = datlen;
419}
b28dea4e 420
f5cda4cb 421void EVP_PKEY_CTX_set_data(EVP_PKEY_CTX *ctx, void *data)
0f113f3e
MC		 422{
423 ctx->data = data;
424}
f5cda4cb
DSH		 425
426void *EVP_PKEY_CTX_get_data(EVP_PKEY_CTX *ctx)
0f113f3e
MC		 427{
428 return ctx->data;
429}
f5cda4cb 430
81cebb8b 431EVP_PKEY *EVP_PKEY_CTX_get0_pkey(EVP_PKEY_CTX *ctx)
0f113f3e
MC		 432{
433 return ctx->pkey;
434}
81cebb8b 435
0e1dba93 436EVP_PKEY *EVP_PKEY_CTX_get0_peerkey(EVP_PKEY_CTX *ctx)
0f113f3e
MC		 437{
438 return ctx->peerkey;
439}
440
f5cda4cb 441void EVP_PKEY_CTX_set_app_data(EVP_PKEY_CTX *ctx, void *data)
0f113f3e
MC		 442{
443 ctx->app_data = data;
444}
f5cda4cb
DSH		 445
446void *EVP_PKEY_CTX_get_app_data(EVP_PKEY_CTX *ctx)
0f113f3e
MC		 447{
448 return ctx->app_data;
449}
ba30bad5
DSH		 450
451void EVP_PKEY_meth_set_init(EVP_PKEY_METHOD *pmeth,
0f113f3e
MC		 452 int (*init) (EVP_PKEY_CTX *ctx))
453{
454 pmeth->init = init;
455}
8bdcef40
DSH		 456
457void EVP_PKEY_meth_set_copy(EVP_PKEY_METHOD *pmeth,
0f113f3e
MC		 458 int (*copy) (EVP_PKEY_CTX *dst,
459 EVP_PKEY_CTX *src))
460{
461 pmeth->copy = copy;
462}
ba30bad5
DSH		 463
464void EVP_PKEY_meth_set_cleanup(EVP_PKEY_METHOD *pmeth,
0f113f3e
MC		 465 void (*cleanup) (EVP_PKEY_CTX *ctx))
466{
467 pmeth->cleanup = cleanup;
468}
ba30bad5
DSH		 469
470void EVP_PKEY_meth_set_paramgen(EVP_PKEY_METHOD *pmeth,
0f113f3e
MC		 471 int (*paramgen_init) (EVP_PKEY_CTX *ctx),
472 int (*paramgen) (EVP_PKEY_CTX *ctx,
473 EVP_PKEY *pkey))
474{
475 pmeth->paramgen_init = paramgen_init;
476 pmeth->paramgen = paramgen;
477}
ba30bad5
DSH		 478
479void EVP_PKEY_meth_set_keygen(EVP_PKEY_METHOD *pmeth,
0f113f3e
MC		 480 int (*keygen_init) (EVP_PKEY_CTX *ctx),
481 int (*keygen) (EVP_PKEY_CTX *ctx,
482 EVP_PKEY *pkey))
483{
484 pmeth->keygen_init = keygen_init;
485 pmeth->keygen = keygen;
486}
ba30bad5
DSH		 487
488void EVP_PKEY_meth_set_sign(EVP_PKEY_METHOD *pmeth,
0f113f3e
MC		 489 int (*sign_init) (EVP_PKEY_CTX *ctx),
490 int (*sign) (EVP_PKEY_CTX *ctx,
491 unsigned char *sig, size_t *siglen,
492 const unsigned char *tbs,
493 size_t tbslen))
494{
495 pmeth->sign_init = sign_init;
496 pmeth->sign = sign;
497}
ba30bad5
DSH		 498
499void EVP_PKEY_meth_set_verify(EVP_PKEY_METHOD *pmeth,
0f113f3e
MC		 500 int (*verify_init) (EVP_PKEY_CTX *ctx),
501 int (*verify) (EVP_PKEY_CTX *ctx,
502 const unsigned char *sig,
503 size_t siglen,
504 const unsigned char *tbs,
505 size_t tbslen))
506{
507 pmeth->verify_init = verify_init;
508 pmeth->verify = verify;
509}
ba30bad5
DSH		 510
511void EVP_PKEY_meth_set_verify_recover(EVP_PKEY_METHOD *pmeth,
0f113f3e
MC		 512 int (*verify_recover_init) (EVP_PKEY_CTX
513 *ctx),
514 int (*verify_recover) (EVP_PKEY_CTX
515 *ctx,
516 unsigned char
517 *sig,
518 size_t *siglen,
519 const unsigned
520 char *tbs,
521 size_t tbslen))
522{
523 pmeth->verify_recover_init = verify_recover_init;
524 pmeth->verify_recover = verify_recover;
525}
ba30bad5
DSH		 526
527void EVP_PKEY_meth_set_signctx(EVP_PKEY_METHOD *pmeth,
0f113f3e
MC		 528 int (*signctx_init) (EVP_PKEY_CTX *ctx,
529 EVP_MD_CTX *mctx),
530 int (*signctx) (EVP_PKEY_CTX *ctx,
531 unsigned char *sig,
532 size_t *siglen,
533 EVP_MD_CTX *mctx))
534{
535 pmeth->signctx_init = signctx_init;
536 pmeth->signctx = signctx;
537}
ba30bad5
DSH		 538
539void EVP_PKEY_meth_set_verifyctx(EVP_PKEY_METHOD *pmeth,
0f113f3e
MC		 540 int (*verifyctx_init) (EVP_PKEY_CTX *ctx,
541 EVP_MD_CTX *mctx),
542 int (*verifyctx) (EVP_PKEY_CTX *ctx,
543 const unsigned char *sig,
544 int siglen,
545 EVP_MD_CTX *mctx))
546{
547 pmeth->verifyctx_init = verifyctx_init;
548 pmeth->verifyctx = verifyctx;
549}
ba30bad5
DSH		 550
551void EVP_PKEY_meth_set_encrypt(EVP_PKEY_METHOD *pmeth,
0f113f3e
MC		 552 int (*encrypt_init) (EVP_PKEY_CTX *ctx),
553 int (*encryptfn) (EVP_PKEY_CTX *ctx,
554 unsigned char *out,
555 size_t *outlen,
556 const unsigned char *in,
557 size_t inlen))
558{
559 pmeth->encrypt_init = encrypt_init;
560 pmeth->encrypt = encryptfn;
561}
ba30bad5
DSH		 562
563void EVP_PKEY_meth_set_decrypt(EVP_PKEY_METHOD *pmeth,
0f113f3e
MC		 564 int (*decrypt_init) (EVP_PKEY_CTX *ctx),
565 int (*decrypt) (EVP_PKEY_CTX *ctx,
566 unsigned char *out,
567 size_t *outlen,
568 const unsigned char *in,
569 size_t inlen))
570{
571 pmeth->decrypt_init = decrypt_init;
572 pmeth->decrypt = decrypt;
573}
ba30bad5
DSH		 574
575void EVP_PKEY_meth_set_derive(EVP_PKEY_METHOD *pmeth,
0f113f3e
MC		 576 int (*derive_init) (EVP_PKEY_CTX *ctx),
577 int (*derive) (EVP_PKEY_CTX *ctx,
578 unsigned char *key,
579 size_t *keylen))
580{
581 pmeth->derive_init = derive_init;
582 pmeth->derive = derive;
583}
ba30bad5
DSH		 584
585void EVP_PKEY_meth_set_ctrl(EVP_PKEY_METHOD *pmeth,
0f113f3e
MC		 586 int (*ctrl) (EVP_PKEY_CTX *ctx, int type, int p1,
587 void *p2),
588 int (*ctrl_str) (EVP_PKEY_CTX *ctx,
589 const char *type,
590 const char *value))
591{
592 pmeth->ctrl = ctrl;
593 pmeth->ctrl_str = ctrl_str;
594}
e7451ed1
DSH		 595
596void EVP_PKEY_meth_get_init(EVP_PKEY_METHOD *pmeth,
597 int (**pinit) (EVP_PKEY_CTX *ctx))
598{
599 *pinit = pmeth->init;
600}
601
602void EVP_PKEY_meth_get_copy(EVP_PKEY_METHOD *pmeth,
603 int (**pcopy) (EVP_PKEY_CTX *dst,
604 EVP_PKEY_CTX *src))
605{
606 *pcopy = pmeth->copy;
607}
608
609void EVP_PKEY_meth_get_cleanup(EVP_PKEY_METHOD *pmeth,
610 void (**pcleanup) (EVP_PKEY_CTX *ctx))
611{
612 *pcleanup = pmeth->cleanup;
613}
614
615void EVP_PKEY_meth_get_paramgen(EVP_PKEY_METHOD *pmeth,
616 int (**pparamgen_init) (EVP_PKEY_CTX *ctx),
617 int (**pparamgen) (EVP_PKEY_CTX *ctx,
618 EVP_PKEY *pkey))
619{
620 if (pparamgen_init)
621 *pparamgen_init = pmeth->paramgen_init;
622 if (pparamgen)
623 *pparamgen = pmeth->paramgen;
624}
625
626void EVP_PKEY_meth_get_keygen(EVP_PKEY_METHOD *pmeth,
627 int (**pkeygen_init) (EVP_PKEY_CTX *ctx),
628 int (**pkeygen) (EVP_PKEY_CTX *ctx,
629 EVP_PKEY *pkey))
630{
631 if (pkeygen_init)
632 *pkeygen_init = pmeth->keygen_init;
633 if (pkeygen)
634 *pkeygen = pmeth->keygen;
635}
636
637void EVP_PKEY_meth_get_sign(EVP_PKEY_METHOD *pmeth,
638 int (**psign_init) (EVP_PKEY_CTX *ctx),
639 int (**psign) (EVP_PKEY_CTX *ctx,
640 unsigned char *sig, size_t *siglen,
641 const unsigned char *tbs,
642 size_t tbslen))
643{
644 if (psign_init)
645 *psign_init = pmeth->sign_init;
646 if (psign)
647 *psign = pmeth->sign;
648}
649
650void EVP_PKEY_meth_get_verify(EVP_PKEY_METHOD *pmeth,
651 int (**pverify_init) (EVP_PKEY_CTX *ctx),
652 int (**pverify) (EVP_PKEY_CTX *ctx,
653 const unsigned char *sig,
654 size_t siglen,
655 const unsigned char *tbs,
656 size_t tbslen))
657{
658 if (pverify_init)
659 *pverify_init = pmeth->verify_init;
660 if (pverify)
661 *pverify = pmeth->verify;
662}
663
664void EVP_PKEY_meth_get_verify_recover(EVP_PKEY_METHOD *pmeth,
665 int (**pverify_recover_init) (EVP_PKEY_CTX
666 *ctx),
667 int (**pverify_recover) (EVP_PKEY_CTX
668 *ctx,
669 unsigned char
670 *sig,
671 size_t *siglen,
672 const unsigned
673 char *tbs,
674 size_t tbslen))
675{
676 if (pverify_recover_init)
677 *pverify_recover_init = pmeth->verify_recover_init;
678 if (pverify_recover)
679 *pverify_recover = pmeth->verify_recover;
680}
681
682void EVP_PKEY_meth_get_signctx(EVP_PKEY_METHOD *pmeth,
683 int (**psignctx_init) (EVP_PKEY_CTX *ctx,
684 EVP_MD_CTX *mctx),
685 int (**psignctx) (EVP_PKEY_CTX *ctx,
686 unsigned char *sig,
687 size_t *siglen,
688 EVP_MD_CTX *mctx))
689{
690 if (psignctx_init)
691 *psignctx_init = pmeth->signctx_init;
692 if (psignctx)
693 *psignctx = pmeth->signctx;
694}
695
696void EVP_PKEY_meth_get_verifyctx(EVP_PKEY_METHOD *pmeth,
697 int (**pverifyctx_init) (EVP_PKEY_CTX *ctx,
698 EVP_MD_CTX *mctx),
699 int (**pverifyctx) (EVP_PKEY_CTX *ctx,
700 const unsigned char *sig,
701 int siglen,
702 EVP_MD_CTX *mctx))
703{
704 if (pverifyctx_init)
705 *pverifyctx_init = pmeth->verifyctx_init;
706 if (pverifyctx)
707 *pverifyctx = pmeth->verifyctx;
708}
709
710void EVP_PKEY_meth_get_encrypt(EVP_PKEY_METHOD *pmeth,
711 int (**pencrypt_init) (EVP_PKEY_CTX *ctx),
712 int (**pencryptfn) (EVP_PKEY_CTX *ctx,
713 unsigned char *out,
714 size_t *outlen,
715 const unsigned char *in,
716 size_t inlen))
717{
718 if (pencrypt_init)
719 *pencrypt_init = pmeth->encrypt_init;
720 if (pencryptfn)
721 *pencryptfn = pmeth->encrypt;
722}
723
724void EVP_PKEY_meth_get_decrypt(EVP_PKEY_METHOD *pmeth,
725 int (**pdecrypt_init) (EVP_PKEY_CTX *ctx),
726 int (**pdecrypt) (EVP_PKEY_CTX *ctx,
727 unsigned char *out,
728 size_t *outlen,
729 const unsigned char *in,
730 size_t inlen))
731{
732 if (pdecrypt_init)
733 *pdecrypt_init = pmeth->decrypt_init;
734 if (pdecrypt)
735 *pdecrypt = pmeth->decrypt;
736}
737
738void EVP_PKEY_meth_get_derive(EVP_PKEY_METHOD *pmeth,
739 int (**pderive_init) (EVP_PKEY_CTX *ctx),
740 int (**pderive) (EVP_PKEY_CTX *ctx,
741 unsigned char *key,
742 size_t *keylen))
743{
744 if (pderive_init)
745 *pderive_init = pmeth->derive_init;
746 if (pderive)
747 *pderive = pmeth->derive;
748}
749
750void EVP_PKEY_meth_get_ctrl(EVP_PKEY_METHOD *pmeth,
751 int (**pctrl) (EVP_PKEY_CTX *ctx, int type, int p1,
752 void *p2),
753 int (**pctrl_str) (EVP_PKEY_CTX *ctx,
754 const char *type,
755 const char *value))
756{
757 if (pctrl)
758 *pctrl = pmeth->ctrl;
759 if (pctrl_str)
760 *pctrl_str = pmeth->ctrl_str;
761}
A mirror of the official openssl repository