1 /* pmeth_lib.c */
2 /*
3 * Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL project
4 * 2006.
5 */
6 /* ====================================================================
7 * Copyright (c) 2006 The OpenSSL Project. All rights reserved.
8 *
9 * Redistribution and use in source and binary forms, with or without
10 * modification, are permitted provided that the following conditions
11 * are met:
12 *
13 * 1. Redistributions of source code must retain the above copyright
14 * notice, this list of conditions and the following disclaimer.
15 *
16 * 2. Redistributions in binary form must reproduce the above copyright
17 * notice, this list of conditions and the following disclaimer in
18 * the documentation and/or other materials provided with the
19 * distribution.
20 *
21 * 3. All advertising materials mentioning features or use of this
22 * software must display the following acknowledgment:
23 * "This product includes software developed by the OpenSSL Project
24 * for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
25 *
26 * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
27 * endorse or promote products derived from this software without
28 * prior written permission. For written permission, please contact
29 * licensing@OpenSSL.org.
30 *
31 * 5. Products derived from this software may not be called "OpenSSL"
32 * nor may "OpenSSL" appear in their names without prior written
33 * permission of the OpenSSL Project.
34 *
35 * 6. Redistributions of any form whatsoever must retain the following
36 * acknowledgment:
37 * "This product includes software developed by the OpenSSL Project
38 * for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
39 *
40 * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
41 * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
42 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
43 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR
44 * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
45 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
46 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
47 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
48 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
49 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
50 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
51 * OF THE POSSIBILITY OF SUCH DAMAGE.
52 * ====================================================================
53 *
54 * This product includes cryptographic software written by Eric Young
55 * (eay@cryptsoft.com). This product includes software written by Tim
56 * Hudson (tjh@cryptsoft.com).
57 *
58 */
59
60 #include <stdio.h>
61 #include <stdlib.h>
62 #include "cryptlib.h"
63 #include <openssl/objects.h>
64 #include <openssl/evp.h>
65 #ifndef OPENSSL_NO_ENGINE
66 # include <openssl/engine.h>
67 #endif
68 #include "asn1_locl.h"
69 #include "evp_locl.h"
70
71 typedef int sk_cmp_fn_type(const char *const *a, const char *const *b);
72
73 DECLARE_STACK_OF(EVP_PKEY_METHOD)
74 STACK_OF(EVP_PKEY_METHOD) *app_pkey_methods = NULL;
75
76 extern const EVP_PKEY_METHOD rsa_pkey_meth, dh_pkey_meth, dsa_pkey_meth;
77 extern const EVP_PKEY_METHOD ec_pkey_meth, hmac_pkey_meth, cmac_pkey_meth;
78 extern const EVP_PKEY_METHOD dhx_pkey_meth;
79
80 static const EVP_PKEY_METHOD *standard_methods[] = {
81 #ifndef OPENSSL_NO_RSA
82 &rsa_pkey_meth,
83 #endif
84 #ifndef OPENSSL_NO_DH
85 &dh_pkey_meth,
86 #endif
87 #ifndef OPENSSL_NO_DSA
88 &dsa_pkey_meth,
89 #endif
90 #ifndef OPENSSL_NO_EC
91 &ec_pkey_meth,
92 #endif
93 &hmac_pkey_meth,
94 #ifndef OPENSSL_NO_CMAC
95 &cmac_pkey_meth,
96 #endif
97 #ifndef OPENSSL_NO_DH
98 &dhx_pkey_meth
99 #endif
100 };
101
102 DECLARE_OBJ_BSEARCH_CMP_FN(const EVP_PKEY_METHOD *, const EVP_PKEY_METHOD *,
103 pmeth);
104
pmeth_cmp(const EVP_PKEY_METHOD * const * a,const EVP_PKEY_METHOD * const * b)105 static int pmeth_cmp(const EVP_PKEY_METHOD *const *a,
106 const EVP_PKEY_METHOD *const *b)
107 {
108 return ((*a)->pkey_id - (*b)->pkey_id);
109 }
110
111 IMPLEMENT_OBJ_BSEARCH_CMP_FN(const EVP_PKEY_METHOD *, const EVP_PKEY_METHOD *,
112 pmeth);
113
EVP_PKEY_meth_find(int type)114 const EVP_PKEY_METHOD *EVP_PKEY_meth_find(int type)
115 {
116 EVP_PKEY_METHOD tmp;
117 const EVP_PKEY_METHOD *t = &tmp, **ret;
118 tmp.pkey_id = type;
119 if (app_pkey_methods) {
120 int idx;
121 idx = sk_EVP_PKEY_METHOD_find(app_pkey_methods, &tmp);
122 if (idx >= 0)
123 return sk_EVP_PKEY_METHOD_value(app_pkey_methods, idx);
124 }
125 ret = OBJ_bsearch_pmeth(&t, standard_methods,
126 sizeof(standard_methods) /
127 sizeof(EVP_PKEY_METHOD *));
128 if (!ret || !*ret)
129 return NULL;
130 return *ret;
131 }
132
int_ctx_new(EVP_PKEY * pkey,ENGINE * e,int id)133 static EVP_PKEY_CTX *int_ctx_new(EVP_PKEY *pkey, ENGINE *e, int id)
134 {
135 EVP_PKEY_CTX *ret;
136 const EVP_PKEY_METHOD *pmeth;
137 if (id == -1) {
138 if (!pkey || !pkey->ameth)
139 return NULL;
140 id = pkey->ameth->pkey_id;
141 }
142 #ifndef OPENSSL_NO_ENGINE
143 if (pkey && pkey->engine)
144 e = pkey->engine;
145 /* Try to find an ENGINE which implements this method */
146 if (e) {
147 if (!ENGINE_init(e)) {
148 EVPerr(EVP_F_INT_CTX_NEW, ERR_R_ENGINE_LIB);
149 return NULL;
150 }
151 } else
152 e = ENGINE_get_pkey_meth_engine(id);
153
154 /*
155 * If an ENGINE handled this method look it up. Othewise use internal
156 * tables.
157 */
158
159 if (e)
160 pmeth = ENGINE_get_pkey_meth(e, id);
161 else
162 #endif
163 pmeth = EVP_PKEY_meth_find(id);
164
165 if (pmeth == NULL) {
166 EVPerr(EVP_F_INT_CTX_NEW, EVP_R_UNSUPPORTED_ALGORITHM);
167 return NULL;
168 }
169
170 ret = OPENSSL_malloc(sizeof(EVP_PKEY_CTX));
171 if (!ret) {
172 #ifndef OPENSSL_NO_ENGINE
173 if (e)
174 ENGINE_finish(e);
175 #endif
176 EVPerr(EVP_F_INT_CTX_NEW, ERR_R_MALLOC_FAILURE);
177 return NULL;
178 }
179 ret->engine = e;
180 ret->pmeth = pmeth;
181 ret->operation = EVP_PKEY_OP_UNDEFINED;
182 ret->pkey = pkey;
183 ret->peerkey = NULL;
184 ret->pkey_gencb = 0;
185 if (pkey)
186 CRYPTO_add(&pkey->references, 1, CRYPTO_LOCK_EVP_PKEY);
187 ret->data = NULL;
188
189 if (pmeth->init) {
190 if (pmeth->init(ret) <= 0) {
191 ret->pmeth = NULL;
192 EVP_PKEY_CTX_free(ret);
193 return NULL;
194 }
195 }
196
197 return ret;
198 }
199
EVP_PKEY_meth_new(int id,int flags)200 EVP_PKEY_METHOD *EVP_PKEY_meth_new(int id, int flags)
201 {
202 EVP_PKEY_METHOD *pmeth;
203
204 pmeth = OPENSSL_malloc(sizeof(EVP_PKEY_METHOD));
205 if (!pmeth)
206 return NULL;
207
208 memset(pmeth, 0, sizeof(EVP_PKEY_METHOD));
209
210 pmeth->pkey_id = id;
211 pmeth->flags = flags | EVP_PKEY_FLAG_DYNAMIC;
212 return pmeth;
213 }
214
EVP_PKEY_meth_get0_info(int * ppkey_id,int * pflags,const EVP_PKEY_METHOD * meth)215 void EVP_PKEY_meth_get0_info(int *ppkey_id, int *pflags,
216 const EVP_PKEY_METHOD *meth)
217 {
218 if (ppkey_id)
219 *ppkey_id = meth->pkey_id;
220 if (pflags)
221 *pflags = meth->flags;
222 }
223
EVP_PKEY_meth_copy(EVP_PKEY_METHOD * dst,const EVP_PKEY_METHOD * src)224 void EVP_PKEY_meth_copy(EVP_PKEY_METHOD *dst, const EVP_PKEY_METHOD *src)
225 {
226
227 dst->init = src->init;
228 dst->copy = src->copy;
229 dst->cleanup = src->cleanup;
230
231 dst->paramgen_init = src->paramgen_init;
232 dst->paramgen = src->paramgen;
233
234 dst->keygen_init = src->keygen_init;
235 dst->keygen = src->keygen;
236
237 dst->sign_init = src->sign_init;
238 dst->sign = src->sign;
239
240 dst->verify_init = src->verify_init;
241 dst->verify = src->verify;
242
243 dst->verify_recover_init = src->verify_recover_init;
244 dst->verify_recover = src->verify_recover;
245
246 dst->signctx_init = src->signctx_init;
247 dst->signctx = src->signctx;
248
249 dst->verifyctx_init = src->verifyctx_init;
250 dst->verifyctx = src->verifyctx;
251
252 dst->encrypt_init = src->encrypt_init;
253 dst->encrypt = src->encrypt;
254
255 dst->decrypt_init = src->decrypt_init;
256 dst->decrypt = src->decrypt;
257
258 dst->derive_init = src->derive_init;
259 dst->derive = src->derive;
260
261 dst->ctrl = src->ctrl;
262 dst->ctrl_str = src->ctrl_str;
263 }
264
EVP_PKEY_meth_free(EVP_PKEY_METHOD * pmeth)265 void EVP_PKEY_meth_free(EVP_PKEY_METHOD *pmeth)
266 {
267 if (pmeth && (pmeth->flags & EVP_PKEY_FLAG_DYNAMIC))
268 OPENSSL_free(pmeth);
269 }
270
EVP_PKEY_CTX_new(EVP_PKEY * pkey,ENGINE * e)271 EVP_PKEY_CTX *EVP_PKEY_CTX_new(EVP_PKEY *pkey, ENGINE *e)
272 {
273 return int_ctx_new(pkey, e, -1);
274 }
275
EVP_PKEY_CTX_new_id(int id,ENGINE * e)276 EVP_PKEY_CTX *EVP_PKEY_CTX_new_id(int id, ENGINE *e)
277 {
278 return int_ctx_new(NULL, e, id);
279 }
280
EVP_PKEY_CTX_dup(EVP_PKEY_CTX * pctx)281 EVP_PKEY_CTX *EVP_PKEY_CTX_dup(EVP_PKEY_CTX *pctx)
282 {
283 EVP_PKEY_CTX *rctx;
284 if (!pctx->pmeth || !pctx->pmeth->copy)
285 return NULL;
286 #ifndef OPENSSL_NO_ENGINE
287 /* Make sure it's safe to copy a pkey context using an ENGINE */
288 if (pctx->engine && !ENGINE_init(pctx->engine)) {
289 EVPerr(EVP_F_EVP_PKEY_CTX_DUP, ERR_R_ENGINE_LIB);
290 return 0;
291 }
292 #endif
293 rctx = OPENSSL_malloc(sizeof(EVP_PKEY_CTX));
294 if (!rctx)
295 return NULL;
296
297 rctx->pmeth = pctx->pmeth;
298 #ifndef OPENSSL_NO_ENGINE
299 rctx->engine = pctx->engine;
300 #endif
301
302 if (pctx->pkey)
303 CRYPTO_add(&pctx->pkey->references, 1, CRYPTO_LOCK_EVP_PKEY);
304
305 rctx->pkey = pctx->pkey;
306
307 if (pctx->peerkey)
308 CRYPTO_add(&pctx->peerkey->references, 1, CRYPTO_LOCK_EVP_PKEY);
309
310 rctx->peerkey = pctx->peerkey;
311
312 rctx->data = NULL;
313 rctx->app_data = NULL;
314 rctx->operation = pctx->operation;
315
316 if (pctx->pmeth->copy(rctx, pctx) > 0)
317 return rctx;
318
319 rctx->pmeth = NULL;
320 EVP_PKEY_CTX_free(rctx);
321 return NULL;
322
323 }
324
EVP_PKEY_meth_add0(const EVP_PKEY_METHOD * pmeth)325 int EVP_PKEY_meth_add0(const EVP_PKEY_METHOD *pmeth)
326 {
327 if (app_pkey_methods == NULL) {
328 app_pkey_methods = sk_EVP_PKEY_METHOD_new(pmeth_cmp);
329 if (!app_pkey_methods)
330 return 0;
331 }
332 if (!sk_EVP_PKEY_METHOD_push(app_pkey_methods, pmeth))
333 return 0;
334 sk_EVP_PKEY_METHOD_sort(app_pkey_methods);
335 return 1;
336 }
337
EVP_PKEY_CTX_free(EVP_PKEY_CTX * ctx)338 void EVP_PKEY_CTX_free(EVP_PKEY_CTX *ctx)
339 {
340 if (ctx == NULL)
341 return;
342 if (ctx->pmeth && ctx->pmeth->cleanup)
343 ctx->pmeth->cleanup(ctx);
344 if (ctx->pkey)
345 EVP_PKEY_free(ctx->pkey);
346 if (ctx->peerkey)
347 EVP_PKEY_free(ctx->peerkey);
348 #ifndef OPENSSL_NO_ENGINE
349 if (ctx->engine)
350 /*
351 * The EVP_PKEY_CTX we used belongs to an ENGINE, release the
352 * functional reference we held for this reason.
353 */
354 ENGINE_finish(ctx->engine);
355 #endif
356 OPENSSL_free(ctx);
357 }
358
EVP_PKEY_CTX_ctrl(EVP_PKEY_CTX * ctx,int keytype,int optype,int cmd,int p1,void * p2)359 int EVP_PKEY_CTX_ctrl(EVP_PKEY_CTX *ctx, int keytype, int optype,
360 int cmd, int p1, void *p2)
361 {
362 int ret;
363 if (!ctx || !ctx->pmeth || !ctx->pmeth->ctrl) {
364 EVPerr(EVP_F_EVP_PKEY_CTX_CTRL, EVP_R_COMMAND_NOT_SUPPORTED);
365 return -2;
366 }
367 if ((keytype != -1) && (ctx->pmeth->pkey_id != keytype))
368 return -1;
369
370 if (ctx->operation == EVP_PKEY_OP_UNDEFINED) {
371 EVPerr(EVP_F_EVP_PKEY_CTX_CTRL, EVP_R_NO_OPERATION_SET);
372 return -1;
373 }
374
375 if ((optype != -1) && !(ctx->operation & optype)) {
376 EVPerr(EVP_F_EVP_PKEY_CTX_CTRL, EVP_R_INVALID_OPERATION);
377 return -1;
378 }
379
380 ret = ctx->pmeth->ctrl(ctx, cmd, p1, p2);
381
382 if (ret == -2)
383 EVPerr(EVP_F_EVP_PKEY_CTX_CTRL, EVP_R_COMMAND_NOT_SUPPORTED);
384
385 return ret;
386
387 }
388
EVP_PKEY_CTX_ctrl_str(EVP_PKEY_CTX * ctx,const char * name,const char * value)389 int EVP_PKEY_CTX_ctrl_str(EVP_PKEY_CTX *ctx,
390 const char *name, const char *value)
391 {
392 if (!ctx || !ctx->pmeth || !ctx->pmeth->ctrl_str) {
393 EVPerr(EVP_F_EVP_PKEY_CTX_CTRL_STR, EVP_R_COMMAND_NOT_SUPPORTED);
394 return -2;
395 }
396 if (!strcmp(name, "digest")) {
397 const EVP_MD *md;
398 if (!value || !(md = EVP_get_digestbyname(value))) {
399 EVPerr(EVP_F_EVP_PKEY_CTX_CTRL_STR, EVP_R_INVALID_DIGEST);
400 return 0;
401 }
402 return EVP_PKEY_CTX_set_signature_md(ctx, md);
403 }
404 return ctx->pmeth->ctrl_str(ctx, name, value);
405 }
406
EVP_PKEY_CTX_get_operation(EVP_PKEY_CTX * ctx)407 int EVP_PKEY_CTX_get_operation(EVP_PKEY_CTX *ctx)
408 {
409 return ctx->operation;
410 }
411
EVP_PKEY_CTX_set0_keygen_info(EVP_PKEY_CTX * ctx,int * dat,int datlen)412 void EVP_PKEY_CTX_set0_keygen_info(EVP_PKEY_CTX *ctx, int *dat, int datlen)
413 {
414 ctx->keygen_info = dat;
415 ctx->keygen_info_count = datlen;
416 }
417
EVP_PKEY_CTX_set_data(EVP_PKEY_CTX * ctx,void * data)418 void EVP_PKEY_CTX_set_data(EVP_PKEY_CTX *ctx, void *data)
419 {
420 ctx->data = data;
421 }
422
EVP_PKEY_CTX_get_data(EVP_PKEY_CTX * ctx)423 void *EVP_PKEY_CTX_get_data(EVP_PKEY_CTX *ctx)
424 {
425 return ctx->data;
426 }
427
EVP_PKEY_CTX_get0_pkey(EVP_PKEY_CTX * ctx)428 EVP_PKEY *EVP_PKEY_CTX_get0_pkey(EVP_PKEY_CTX *ctx)
429 {
430 return ctx->pkey;
431 }
432
EVP_PKEY_CTX_get0_peerkey(EVP_PKEY_CTX * ctx)433 EVP_PKEY *EVP_PKEY_CTX_get0_peerkey(EVP_PKEY_CTX *ctx)
434 {
435 return ctx->peerkey;
436 }
437
EVP_PKEY_CTX_set_app_data(EVP_PKEY_CTX * ctx,void * data)438 void EVP_PKEY_CTX_set_app_data(EVP_PKEY_CTX *ctx, void *data)
439 {
440 ctx->app_data = data;
441 }
442
EVP_PKEY_CTX_get_app_data(EVP_PKEY_CTX * ctx)443 void *EVP_PKEY_CTX_get_app_data(EVP_PKEY_CTX *ctx)
444 {
445 return ctx->app_data;
446 }
447
EVP_PKEY_meth_set_init(EVP_PKEY_METHOD * pmeth,int (* init)(EVP_PKEY_CTX * ctx))448 void EVP_PKEY_meth_set_init(EVP_PKEY_METHOD *pmeth,
449 int (*init) (EVP_PKEY_CTX *ctx))
450 {
451 pmeth->init = init;
452 }
453
EVP_PKEY_meth_set_copy(EVP_PKEY_METHOD * pmeth,int (* copy)(EVP_PKEY_CTX * dst,EVP_PKEY_CTX * src))454 void EVP_PKEY_meth_set_copy(EVP_PKEY_METHOD *pmeth,
455 int (*copy) (EVP_PKEY_CTX *dst,
456 EVP_PKEY_CTX *src))
457 {
458 pmeth->copy = copy;
459 }
460
EVP_PKEY_meth_set_cleanup(EVP_PKEY_METHOD * pmeth,void (* cleanup)(EVP_PKEY_CTX * ctx))461 void EVP_PKEY_meth_set_cleanup(EVP_PKEY_METHOD *pmeth,
462 void (*cleanup) (EVP_PKEY_CTX *ctx))
463 {
464 pmeth->cleanup = cleanup;
465 }
466
EVP_PKEY_meth_set_paramgen(EVP_PKEY_METHOD * pmeth,int (* paramgen_init)(EVP_PKEY_CTX * ctx),int (* paramgen)(EVP_PKEY_CTX * ctx,EVP_PKEY * pkey))467 void EVP_PKEY_meth_set_paramgen(EVP_PKEY_METHOD *pmeth,
468 int (*paramgen_init) (EVP_PKEY_CTX *ctx),
469 int (*paramgen) (EVP_PKEY_CTX *ctx,
470 EVP_PKEY *pkey))
471 {
472 pmeth->paramgen_init = paramgen_init;
473 pmeth->paramgen = paramgen;
474 }
475
EVP_PKEY_meth_set_keygen(EVP_PKEY_METHOD * pmeth,int (* keygen_init)(EVP_PKEY_CTX * ctx),int (* keygen)(EVP_PKEY_CTX * ctx,EVP_PKEY * pkey))476 void EVP_PKEY_meth_set_keygen(EVP_PKEY_METHOD *pmeth,
477 int (*keygen_init) (EVP_PKEY_CTX *ctx),
478 int (*keygen) (EVP_PKEY_CTX *ctx,
479 EVP_PKEY *pkey))
480 {
481 pmeth->keygen_init = keygen_init;
482 pmeth->keygen = keygen;
483 }
484
EVP_PKEY_meth_set_sign(EVP_PKEY_METHOD * pmeth,int (* sign_init)(EVP_PKEY_CTX * ctx),int (* sign)(EVP_PKEY_CTX * ctx,unsigned char * sig,size_t * siglen,const unsigned char * tbs,size_t tbslen))485 void EVP_PKEY_meth_set_sign(EVP_PKEY_METHOD *pmeth,
486 int (*sign_init) (EVP_PKEY_CTX *ctx),
487 int (*sign) (EVP_PKEY_CTX *ctx,
488 unsigned char *sig, size_t *siglen,
489 const unsigned char *tbs,
490 size_t tbslen))
491 {
492 pmeth->sign_init = sign_init;
493 pmeth->sign = sign;
494 }
495
EVP_PKEY_meth_set_verify(EVP_PKEY_METHOD * pmeth,int (* verify_init)(EVP_PKEY_CTX * ctx),int (* verify)(EVP_PKEY_CTX * ctx,const unsigned char * sig,size_t siglen,const unsigned char * tbs,size_t tbslen))496 void EVP_PKEY_meth_set_verify(EVP_PKEY_METHOD *pmeth,
497 int (*verify_init) (EVP_PKEY_CTX *ctx),
498 int (*verify) (EVP_PKEY_CTX *ctx,
499 const unsigned char *sig,
500 size_t siglen,
501 const unsigned char *tbs,
502 size_t tbslen))
503 {
504 pmeth->verify_init = verify_init;
505 pmeth->verify = verify;
506 }
507
EVP_PKEY_meth_set_verify_recover(EVP_PKEY_METHOD * pmeth,int (* verify_recover_init)(EVP_PKEY_CTX * ctx),int (* verify_recover)(EVP_PKEY_CTX * ctx,unsigned char * sig,size_t * siglen,const unsigned char * tbs,size_t tbslen))508 void EVP_PKEY_meth_set_verify_recover(EVP_PKEY_METHOD *pmeth,
509 int (*verify_recover_init) (EVP_PKEY_CTX
510 *ctx),
511 int (*verify_recover) (EVP_PKEY_CTX
512 *ctx,
513 unsigned char
514 *sig,
515 size_t *siglen,
516 const unsigned
517 char *tbs,
518 size_t tbslen))
519 {
520 pmeth->verify_recover_init = verify_recover_init;
521 pmeth->verify_recover = verify_recover;
522 }
523
EVP_PKEY_meth_set_signctx(EVP_PKEY_METHOD * pmeth,int (* signctx_init)(EVP_PKEY_CTX * ctx,EVP_MD_CTX * mctx),int (* signctx)(EVP_PKEY_CTX * ctx,unsigned char * sig,size_t * siglen,EVP_MD_CTX * mctx))524 void EVP_PKEY_meth_set_signctx(EVP_PKEY_METHOD *pmeth,
525 int (*signctx_init) (EVP_PKEY_CTX *ctx,
526 EVP_MD_CTX *mctx),
527 int (*signctx) (EVP_PKEY_CTX *ctx,
528 unsigned char *sig,
529 size_t *siglen,
530 EVP_MD_CTX *mctx))
531 {
532 pmeth->signctx_init = signctx_init;
533 pmeth->signctx = signctx;
534 }
535
EVP_PKEY_meth_set_verifyctx(EVP_PKEY_METHOD * pmeth,int (* verifyctx_init)(EVP_PKEY_CTX * ctx,EVP_MD_CTX * mctx),int (* verifyctx)(EVP_PKEY_CTX * ctx,const unsigned char * sig,int siglen,EVP_MD_CTX * mctx))536 void EVP_PKEY_meth_set_verifyctx(EVP_PKEY_METHOD *pmeth,
537 int (*verifyctx_init) (EVP_PKEY_CTX *ctx,
538 EVP_MD_CTX *mctx),
539 int (*verifyctx) (EVP_PKEY_CTX *ctx,
540 const unsigned char *sig,
541 int siglen,
542 EVP_MD_CTX *mctx))
543 {
544 pmeth->verifyctx_init = verifyctx_init;
545 pmeth->verifyctx = verifyctx;
546 }
547
EVP_PKEY_meth_set_encrypt(EVP_PKEY_METHOD * pmeth,int (* encrypt_init)(EVP_PKEY_CTX * ctx),int (* encryptfn)(EVP_PKEY_CTX * ctx,unsigned char * out,size_t * outlen,const unsigned char * in,size_t inlen))548 void EVP_PKEY_meth_set_encrypt(EVP_PKEY_METHOD *pmeth,
549 int (*encrypt_init) (EVP_PKEY_CTX *ctx),
550 int (*encryptfn) (EVP_PKEY_CTX *ctx,
551 unsigned char *out,
552 size_t *outlen,
553 const unsigned char *in,
554 size_t inlen))
555 {
556 pmeth->encrypt_init = encrypt_init;
557 pmeth->encrypt = encryptfn;
558 }
559
EVP_PKEY_meth_set_decrypt(EVP_PKEY_METHOD * pmeth,int (* decrypt_init)(EVP_PKEY_CTX * ctx),int (* decrypt)(EVP_PKEY_CTX * ctx,unsigned char * out,size_t * outlen,const unsigned char * in,size_t inlen))560 void EVP_PKEY_meth_set_decrypt(EVP_PKEY_METHOD *pmeth,
561 int (*decrypt_init) (EVP_PKEY_CTX *ctx),
562 int (*decrypt) (EVP_PKEY_CTX *ctx,
563 unsigned char *out,
564 size_t *outlen,
565 const unsigned char *in,
566 size_t inlen))
567 {
568 pmeth->decrypt_init = decrypt_init;
569 pmeth->decrypt = decrypt;
570 }
571
EVP_PKEY_meth_set_derive(EVP_PKEY_METHOD * pmeth,int (* derive_init)(EVP_PKEY_CTX * ctx),int (* derive)(EVP_PKEY_CTX * ctx,unsigned char * key,size_t * keylen))572 void EVP_PKEY_meth_set_derive(EVP_PKEY_METHOD *pmeth,
573 int (*derive_init) (EVP_PKEY_CTX *ctx),
574 int (*derive) (EVP_PKEY_CTX *ctx,
575 unsigned char *key,
576 size_t *keylen))
577 {
578 pmeth->derive_init = derive_init;
579 pmeth->derive = derive;
580 }
581
EVP_PKEY_meth_set_ctrl(EVP_PKEY_METHOD * pmeth,int (* ctrl)(EVP_PKEY_CTX * ctx,int type,int p1,void * p2),int (* ctrl_str)(EVP_PKEY_CTX * ctx,const char * type,const char * value))582 void EVP_PKEY_meth_set_ctrl(EVP_PKEY_METHOD *pmeth,
583 int (*ctrl) (EVP_PKEY_CTX *ctx, int type, int p1,
584 void *p2),
585 int (*ctrl_str) (EVP_PKEY_CTX *ctx,
586 const char *type,
587 const char *value))
588 {
589 pmeth->ctrl = ctrl;
590 pmeth->ctrl_str = ctrl_str;
591 }
592
EVP_PKEY_meth_get_init(EVP_PKEY_METHOD * pmeth,int (** pinit)(EVP_PKEY_CTX * ctx))593 void EVP_PKEY_meth_get_init(EVP_PKEY_METHOD *pmeth,
594 int (**pinit) (EVP_PKEY_CTX *ctx))
595 {
596 *pinit = pmeth->init;
597 }
598
EVP_PKEY_meth_get_copy(EVP_PKEY_METHOD * pmeth,int (** pcopy)(EVP_PKEY_CTX * dst,EVP_PKEY_CTX * src))599 void EVP_PKEY_meth_get_copy(EVP_PKEY_METHOD *pmeth,
600 int (**pcopy) (EVP_PKEY_CTX *dst,
601 EVP_PKEY_CTX *src))
602 {
603 *pcopy = pmeth->copy;
604 }
605
EVP_PKEY_meth_get_cleanup(EVP_PKEY_METHOD * pmeth,void (** pcleanup)(EVP_PKEY_CTX * ctx))606 void EVP_PKEY_meth_get_cleanup(EVP_PKEY_METHOD *pmeth,
607 void (**pcleanup) (EVP_PKEY_CTX *ctx))
608 {
609 *pcleanup = pmeth->cleanup;
610 }
611
EVP_PKEY_meth_get_paramgen(EVP_PKEY_METHOD * pmeth,int (** pparamgen_init)(EVP_PKEY_CTX * ctx),int (** pparamgen)(EVP_PKEY_CTX * ctx,EVP_PKEY * pkey))612 void EVP_PKEY_meth_get_paramgen(EVP_PKEY_METHOD *pmeth,
613 int (**pparamgen_init) (EVP_PKEY_CTX *ctx),
614 int (**pparamgen) (EVP_PKEY_CTX *ctx,
615 EVP_PKEY *pkey))
616 {
617 if (pparamgen_init)
618 *pparamgen_init = pmeth->paramgen_init;
619 if (pparamgen)
620 *pparamgen = pmeth->paramgen;
621 }
622
EVP_PKEY_meth_get_keygen(EVP_PKEY_METHOD * pmeth,int (** pkeygen_init)(EVP_PKEY_CTX * ctx),int (** pkeygen)(EVP_PKEY_CTX * ctx,EVP_PKEY * pkey))623 void EVP_PKEY_meth_get_keygen(EVP_PKEY_METHOD *pmeth,
624 int (**pkeygen_init) (EVP_PKEY_CTX *ctx),
625 int (**pkeygen) (EVP_PKEY_CTX *ctx,
626 EVP_PKEY *pkey))
627 {
628 if (pkeygen_init)
629 *pkeygen_init = pmeth->keygen_init;
630 if (pkeygen)
631 *pkeygen = pmeth->keygen;
632 }
633
EVP_PKEY_meth_get_sign(EVP_PKEY_METHOD * pmeth,int (** psign_init)(EVP_PKEY_CTX * ctx),int (** psign)(EVP_PKEY_CTX * ctx,unsigned char * sig,size_t * siglen,const unsigned char * tbs,size_t tbslen))634 void EVP_PKEY_meth_get_sign(EVP_PKEY_METHOD *pmeth,
635 int (**psign_init) (EVP_PKEY_CTX *ctx),
636 int (**psign) (EVP_PKEY_CTX *ctx,
637 unsigned char *sig, size_t *siglen,
638 const unsigned char *tbs,
639 size_t tbslen))
640 {
641 if (psign_init)
642 *psign_init = pmeth->sign_init;
643 if (psign)
644 *psign = pmeth->sign;
645 }
646
EVP_PKEY_meth_get_verify(EVP_PKEY_METHOD * pmeth,int (** pverify_init)(EVP_PKEY_CTX * ctx),int (** pverify)(EVP_PKEY_CTX * ctx,const unsigned char * sig,size_t siglen,const unsigned char * tbs,size_t tbslen))647 void EVP_PKEY_meth_get_verify(EVP_PKEY_METHOD *pmeth,
648 int (**pverify_init) (EVP_PKEY_CTX *ctx),
649 int (**pverify) (EVP_PKEY_CTX *ctx,
650 const unsigned char *sig,
651 size_t siglen,
652 const unsigned char *tbs,
653 size_t tbslen))
654 {
655 if (pverify_init)
656 *pverify_init = pmeth->verify_init;
657 if (pverify)
658 *pverify = pmeth->verify;
659 }
660
EVP_PKEY_meth_get_verify_recover(EVP_PKEY_METHOD * pmeth,int (** pverify_recover_init)(EVP_PKEY_CTX * ctx),int (** pverify_recover)(EVP_PKEY_CTX * ctx,unsigned char * sig,size_t * siglen,const unsigned char * tbs,size_t tbslen))661 void EVP_PKEY_meth_get_verify_recover(EVP_PKEY_METHOD *pmeth,
662 int (**pverify_recover_init) (EVP_PKEY_CTX
663 *ctx),
664 int (**pverify_recover) (EVP_PKEY_CTX
665 *ctx,
666 unsigned char
667 *sig,
668 size_t *siglen,
669 const unsigned
670 char *tbs,
671 size_t tbslen))
672 {
673 if (pverify_recover_init)
674 *pverify_recover_init = pmeth->verify_recover_init;
675 if (pverify_recover)
676 *pverify_recover = pmeth->verify_recover;
677 }
678
EVP_PKEY_meth_get_signctx(EVP_PKEY_METHOD * pmeth,int (** psignctx_init)(EVP_PKEY_CTX * ctx,EVP_MD_CTX * mctx),int (** psignctx)(EVP_PKEY_CTX * ctx,unsigned char * sig,size_t * siglen,EVP_MD_CTX * mctx))679 void EVP_PKEY_meth_get_signctx(EVP_PKEY_METHOD *pmeth,
680 int (**psignctx_init) (EVP_PKEY_CTX *ctx,
681 EVP_MD_CTX *mctx),
682 int (**psignctx) (EVP_PKEY_CTX *ctx,
683 unsigned char *sig,
684 size_t *siglen,
685 EVP_MD_CTX *mctx))
686 {
687 if (psignctx_init)
688 *psignctx_init = pmeth->signctx_init;
689 if (psignctx)
690 *psignctx = pmeth->signctx;
691 }
692
EVP_PKEY_meth_get_verifyctx(EVP_PKEY_METHOD * pmeth,int (** pverifyctx_init)(EVP_PKEY_CTX * ctx,EVP_MD_CTX * mctx),int (** pverifyctx)(EVP_PKEY_CTX * ctx,const unsigned char * sig,int siglen,EVP_MD_CTX * mctx))693 void EVP_PKEY_meth_get_verifyctx(EVP_PKEY_METHOD *pmeth,
694 int (**pverifyctx_init) (EVP_PKEY_CTX *ctx,
695 EVP_MD_CTX *mctx),
696 int (**pverifyctx) (EVP_PKEY_CTX *ctx,
697 const unsigned char *sig,
698 int siglen,
699 EVP_MD_CTX *mctx))
700 {
701 if (pverifyctx_init)
702 *pverifyctx_init = pmeth->verifyctx_init;
703 if (pverifyctx)
704 *pverifyctx = pmeth->verifyctx;
705 }
706
EVP_PKEY_meth_get_encrypt(EVP_PKEY_METHOD * pmeth,int (** pencrypt_init)(EVP_PKEY_CTX * ctx),int (** pencryptfn)(EVP_PKEY_CTX * ctx,unsigned char * out,size_t * outlen,const unsigned char * in,size_t inlen))707 void EVP_PKEY_meth_get_encrypt(EVP_PKEY_METHOD *pmeth,
708 int (**pencrypt_init) (EVP_PKEY_CTX *ctx),
709 int (**pencryptfn) (EVP_PKEY_CTX *ctx,
710 unsigned char *out,
711 size_t *outlen,
712 const unsigned char *in,
713 size_t inlen))
714 {
715 if (pencrypt_init)
716 *pencrypt_init = pmeth->encrypt_init;
717 if (pencryptfn)
718 *pencryptfn = pmeth->encrypt;
719 }
720
EVP_PKEY_meth_get_decrypt(EVP_PKEY_METHOD * pmeth,int (** pdecrypt_init)(EVP_PKEY_CTX * ctx),int (** pdecrypt)(EVP_PKEY_CTX * ctx,unsigned char * out,size_t * outlen,const unsigned char * in,size_t inlen))721 void EVP_PKEY_meth_get_decrypt(EVP_PKEY_METHOD *pmeth,
722 int (**pdecrypt_init) (EVP_PKEY_CTX *ctx),
723 int (**pdecrypt) (EVP_PKEY_CTX *ctx,
724 unsigned char *out,
725 size_t *outlen,
726 const unsigned char *in,
727 size_t inlen))
728 {
729 if (pdecrypt_init)
730 *pdecrypt_init = pmeth->decrypt_init;
731 if (pdecrypt)
732 *pdecrypt = pmeth->decrypt;
733 }
734
EVP_PKEY_meth_get_derive(EVP_PKEY_METHOD * pmeth,int (** pderive_init)(EVP_PKEY_CTX * ctx),int (** pderive)(EVP_PKEY_CTX * ctx,unsigned char * key,size_t * keylen))735 void EVP_PKEY_meth_get_derive(EVP_PKEY_METHOD *pmeth,
736 int (**pderive_init) (EVP_PKEY_CTX *ctx),
737 int (**pderive) (EVP_PKEY_CTX *ctx,
738 unsigned char *key,
739 size_t *keylen))
740 {
741 if (pderive_init)
742 *pderive_init = pmeth->derive_init;
743 if (pderive)
744 *pderive = pmeth->derive;
745 }
746
EVP_PKEY_meth_get_ctrl(EVP_PKEY_METHOD * pmeth,int (** pctrl)(EVP_PKEY_CTX * ctx,int type,int p1,void * p2),int (** pctrl_str)(EVP_PKEY_CTX * ctx,const char * type,const char * value))747 void EVP_PKEY_meth_get_ctrl(EVP_PKEY_METHOD *pmeth,
748 int (**pctrl) (EVP_PKEY_CTX *ctx, int type, int p1,
749 void *p2),
750 int (**pctrl_str) (EVP_PKEY_CTX *ctx,
751 const char *type,
752 const char *value))
753 {
754 if (pctrl)
755 *pctrl = pmeth->ctrl;
756 if (pctrl_str)
757 *pctrl_str = pmeth->ctrl_str;
758 }
759