source: EcnlProtoTool/trunk/openssl-1.1.0e/crypto/evp/pmeth_lib.c

Last change on this file was 331, checked in by coas-nagasima, 6 years ago

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