1EVP_PKEY_METH_NEW(3ossl) OpenSSL EVP_PKEY_METH_NEW(3ossl)
2
6 EVP_PKEY_meth_new, EVP_PKEY_meth_free, EVP_PKEY_meth_copy,
7 EVP_PKEY_meth_find, EVP_PKEY_meth_add0, EVP_PKEY_METHOD,
8 EVP_PKEY_meth_set_init, EVP_PKEY_meth_set_copy,
9 EVP_PKEY_meth_set_cleanup, EVP_PKEY_meth_set_paramgen,
10 EVP_PKEY_meth_set_keygen, EVP_PKEY_meth_set_sign,
11 EVP_PKEY_meth_set_verify, EVP_PKEY_meth_set_verify_recover,
12 EVP_PKEY_meth_set_signctx, EVP_PKEY_meth_set_verifyctx,
13 EVP_PKEY_meth_set_encrypt, EVP_PKEY_meth_set_decrypt,
14 EVP_PKEY_meth_set_derive, EVP_PKEY_meth_set_ctrl,
15 EVP_PKEY_meth_set_digestsign, EVP_PKEY_meth_set_digestverify,
16 EVP_PKEY_meth_set_check, EVP_PKEY_meth_set_public_check,
17 EVP_PKEY_meth_set_param_check, EVP_PKEY_meth_set_digest_custom,
18 EVP_PKEY_meth_get_init, EVP_PKEY_meth_get_copy,
19 EVP_PKEY_meth_get_cleanup, EVP_PKEY_meth_get_paramgen,
20 EVP_PKEY_meth_get_keygen, EVP_PKEY_meth_get_sign,
21 EVP_PKEY_meth_get_verify, EVP_PKEY_meth_get_verify_recover,
22 EVP_PKEY_meth_get_signctx, EVP_PKEY_meth_get_verifyctx,
23 EVP_PKEY_meth_get_encrypt, EVP_PKEY_meth_get_decrypt,
24 EVP_PKEY_meth_get_derive, EVP_PKEY_meth_get_ctrl,
25 EVP_PKEY_meth_get_digestsign, EVP_PKEY_meth_get_digestverify,
26 EVP_PKEY_meth_get_check, EVP_PKEY_meth_get_public_check,
27 EVP_PKEY_meth_get_param_check, EVP_PKEY_meth_get_digest_custom,
28 EVP_PKEY_meth_remove - manipulating EVP_PKEY_METHOD structure
29
31 #include <openssl/evp.h>
32 The following functions have been deprecated since OpenSSL 3.0, and can
34 be hidden entirely by defining OPENSSL_API_COMPAT with a suitable
35 version value, see openssl_user_macros(7):
36 typedef struct evp_pkey_method_st EVP_PKEY_METHOD;
38 EVP_PKEY_METHOD *EVP_PKEY_meth_new(int id, int flags);
40 void EVP_PKEY_meth_free(EVP_PKEY_METHOD *pmeth);
41 void EVP_PKEY_meth_copy(EVP_PKEY_METHOD *dst, const EVP_PKEY_METHOD *src);
42 const EVP_PKEY_METHOD *EVP_PKEY_meth_find(int type);
43 int EVP_PKEY_meth_add0(const EVP_PKEY_METHOD *pmeth);
44 int EVP_PKEY_meth_remove(const EVP_PKEY_METHOD *pmeth);
45 void EVP_PKEY_meth_set_init(EVP_PKEY_METHOD *pmeth,
47 int (*init) (EVP_PKEY_CTX *ctx));
48 void EVP_PKEY_meth_set_copy(EVP_PKEY_METHOD *pmeth,
49 int (*copy) (EVP_PKEY_CTX *dst,
50 const EVP_PKEY_CTX *src));
51 void EVP_PKEY_meth_set_cleanup(EVP_PKEY_METHOD *pmeth,
52 void (*cleanup) (EVP_PKEY_CTX *ctx));
53 void EVP_PKEY_meth_set_paramgen(EVP_PKEY_METHOD *pmeth,
54 int (*paramgen_init) (EVP_PKEY_CTX *ctx),
55 int (*paramgen) (EVP_PKEY_CTX *ctx,
56 EVP_PKEY *pkey));
57 void EVP_PKEY_meth_set_keygen(EVP_PKEY_METHOD *pmeth,
58 int (*keygen_init) (EVP_PKEY_CTX *ctx),
59 int (*keygen) (EVP_PKEY_CTX *ctx,
60 EVP_PKEY *pkey));
61 void EVP_PKEY_meth_set_sign(EVP_PKEY_METHOD *pmeth,
62 int (*sign_init) (EVP_PKEY_CTX *ctx),
63 int (*sign) (EVP_PKEY_CTX *ctx,
64 unsigned char *sig, size_t *siglen,
65 const unsigned char *tbs,
66 size_t tbslen));
67 void EVP_PKEY_meth_set_verify(EVP_PKEY_METHOD *pmeth,
68 int (*verify_init) (EVP_PKEY_CTX *ctx),
69 int (*verify) (EVP_PKEY_CTX *ctx,
70 const unsigned char *sig,
71 size_t siglen,
72 const unsigned char *tbs,
73 size_t tbslen));
74 void EVP_PKEY_meth_set_verify_recover(EVP_PKEY_METHOD *pmeth,
75 int (*verify_recover_init) (EVP_PKEY_CTX
76 *ctx),
77 int (*verify_recover) (EVP_PKEY_CTX
78 *ctx,
79 unsigned char
80 *sig,
81 size_t *siglen,
82 const unsigned
83 char *tbs,
84 size_t tbslen));
85 void EVP_PKEY_meth_set_signctx(EVP_PKEY_METHOD *pmeth,
86 int (*signctx_init) (EVP_PKEY_CTX *ctx,
87 EVP_MD_CTX *mctx),
88 int (*signctx) (EVP_PKEY_CTX *ctx,
89 unsigned char *sig,
90 size_t *siglen,
91 EVP_MD_CTX *mctx));
92 void EVP_PKEY_meth_set_verifyctx(EVP_PKEY_METHOD *pmeth,
93 int (*verifyctx_init) (EVP_PKEY_CTX *ctx,
94 EVP_MD_CTX *mctx),
95 int (*verifyctx) (EVP_PKEY_CTX *ctx,
96 const unsigned char *sig,
97 int siglen,
98 EVP_MD_CTX *mctx));
99 void EVP_PKEY_meth_set_encrypt(EVP_PKEY_METHOD *pmeth,
100 int (*encrypt_init) (EVP_PKEY_CTX *ctx),
101 int (*encryptfn) (EVP_PKEY_CTX *ctx,
102 unsigned char *out,
103 size_t *outlen,
104 const unsigned char *in,
105 size_t inlen));
106 void EVP_PKEY_meth_set_decrypt(EVP_PKEY_METHOD *pmeth,
107 int (*decrypt_init) (EVP_PKEY_CTX *ctx),
108 int (*decrypt) (EVP_PKEY_CTX *ctx,
109 unsigned char *out,
110 size_t *outlen,
111 const unsigned char *in,
112 size_t inlen));
113 void EVP_PKEY_meth_set_derive(EVP_PKEY_METHOD *pmeth,
114 int (*derive_init) (EVP_PKEY_CTX *ctx),
115 int (*derive) (EVP_PKEY_CTX *ctx,
116 unsigned char *key,
117 size_t *keylen));
118 void EVP_PKEY_meth_set_ctrl(EVP_PKEY_METHOD *pmeth,
119 int (*ctrl) (EVP_PKEY_CTX *ctx, int type, int p1,
120 void *p2),
121 int (*ctrl_str) (EVP_PKEY_CTX *ctx,
122 const char *type,
123 const char *value));
124 void EVP_PKEY_meth_set_digestsign(EVP_PKEY_METHOD *pmeth,
125 int (*digestsign) (EVP_MD_CTX *ctx,
126 unsigned char *sig,
127 size_t *siglen,
128 const unsigned char *tbs,
129 size_t tbslen));
130 void EVP_PKEY_meth_set_digestverify(EVP_PKEY_METHOD *pmeth,
131 int (*digestverify) (EVP_MD_CTX *ctx,
132 const unsigned char *sig,
133 size_t siglen,
134 const unsigned char *tbs,
135 size_t tbslen));
136 void EVP_PKEY_meth_set_check(EVP_PKEY_METHOD *pmeth,
137 int (*check) (EVP_PKEY *pkey));
138 void EVP_PKEY_meth_set_public_check(EVP_PKEY_METHOD *pmeth,
139 int (*check) (EVP_PKEY *pkey));
140 void EVP_PKEY_meth_set_param_check(EVP_PKEY_METHOD *pmeth,
141 int (*check) (EVP_PKEY *pkey));
142 void EVP_PKEY_meth_set_digest_custom(EVP_PKEY_METHOD *pmeth,
143 int (*digest_custom) (EVP_PKEY_CTX *ctx,
144 EVP_MD_CTX *mctx));
145 void EVP_PKEY_meth_get_init(const EVP_PKEY_METHOD *pmeth,
147 int (**pinit) (EVP_PKEY_CTX *ctx));
148 void EVP_PKEY_meth_get_copy(const EVP_PKEY_METHOD *pmeth,
149 int (**pcopy) (EVP_PKEY_CTX *dst,
150 EVP_PKEY_CTX *src));
151 void EVP_PKEY_meth_get_cleanup(const EVP_PKEY_METHOD *pmeth,
152 void (**pcleanup) (EVP_PKEY_CTX *ctx));
153 void EVP_PKEY_meth_get_paramgen(const EVP_PKEY_METHOD *pmeth,
154 int (**pparamgen_init) (EVP_PKEY_CTX *ctx),
155 int (**pparamgen) (EVP_PKEY_CTX *ctx,
156 EVP_PKEY *pkey));
157 void EVP_PKEY_meth_get_keygen(const EVP_PKEY_METHOD *pmeth,
158 int (**pkeygen_init) (EVP_PKEY_CTX *ctx),
159 int (**pkeygen) (EVP_PKEY_CTX *ctx,
160 EVP_PKEY *pkey));
161 void EVP_PKEY_meth_get_sign(const EVP_PKEY_METHOD *pmeth,
162 int (**psign_init) (EVP_PKEY_CTX *ctx),
163 int (**psign) (EVP_PKEY_CTX *ctx,
164 unsigned char *sig, size_t *siglen,
165 const unsigned char *tbs,
166 size_t tbslen));
167 void EVP_PKEY_meth_get_verify(const EVP_PKEY_METHOD *pmeth,
168 int (**pverify_init) (EVP_PKEY_CTX *ctx),
169 int (**pverify) (EVP_PKEY_CTX *ctx,
170 const unsigned char *sig,
171 size_t siglen,
172 const unsigned char *tbs,
173 size_t tbslen));
174 void EVP_PKEY_meth_get_verify_recover(const EVP_PKEY_METHOD *pmeth,
175 int (**pverify_recover_init) (EVP_PKEY_CTX
176 *ctx),
177 int (**pverify_recover) (EVP_PKEY_CTX
178 *ctx,
179 unsigned char
180 *sig,
181 size_t *siglen,
182 const unsigned
183 char *tbs,
184 size_t tbslen));
185 void EVP_PKEY_meth_get_signctx(const EVP_PKEY_METHOD *pmeth,
186 int (**psignctx_init) (EVP_PKEY_CTX *ctx,
187 EVP_MD_CTX *mctx),
188 int (**psignctx) (EVP_PKEY_CTX *ctx,
189 unsigned char *sig,
190 size_t *siglen,
191 EVP_MD_CTX *mctx));
192 void EVP_PKEY_meth_get_verifyctx(const EVP_PKEY_METHOD *pmeth,
193 int (**pverifyctx_init) (EVP_PKEY_CTX *ctx,
194 EVP_MD_CTX *mctx),
195 int (**pverifyctx) (EVP_PKEY_CTX *ctx,
196 const unsigned char *sig,
197 int siglen,
198 EVP_MD_CTX *mctx));
199 void EVP_PKEY_meth_get_encrypt(const EVP_PKEY_METHOD *pmeth,
200 int (**pencrypt_init) (EVP_PKEY_CTX *ctx),
201 int (**pencryptfn) (EVP_PKEY_CTX *ctx,
202 unsigned char *out,
203 size_t *outlen,
204 const unsigned char *in,
205 size_t inlen));
206 void EVP_PKEY_meth_get_decrypt(const EVP_PKEY_METHOD *pmeth,
207 int (**pdecrypt_init) (EVP_PKEY_CTX *ctx),
208 int (**pdecrypt) (EVP_PKEY_CTX *ctx,
209 unsigned char *out,
210 size_t *outlen,
211 const unsigned char *in,
212 size_t inlen));
213 void EVP_PKEY_meth_get_derive(const EVP_PKEY_METHOD *pmeth,
214 int (**pderive_init) (EVP_PKEY_CTX *ctx),
215 int (**pderive) (EVP_PKEY_CTX *ctx,
216 unsigned char *key,
217 size_t *keylen));
218 void EVP_PKEY_meth_get_ctrl(const EVP_PKEY_METHOD *pmeth,
219 int (**pctrl) (EVP_PKEY_CTX *ctx, int type, int p1,
220 void *p2),
221 int (**pctrl_str) (EVP_PKEY_CTX *ctx,
222 const char *type,
223 const char *value));
224 void EVP_PKEY_meth_get_digestsign(const EVP_PKEY_METHOD *pmeth,
225 int (**digestsign) (EVP_MD_CTX *ctx,
226 unsigned char *sig,
227 size_t *siglen,
228 const unsigned char *tbs,
229 size_t tbslen));
230 void EVP_PKEY_meth_get_digestverify(const EVP_PKEY_METHOD *pmeth,
231 int (**digestverify) (EVP_MD_CTX *ctx,
232 const unsigned char *sig,
233 size_t siglen,
234 const unsigned char *tbs,
235 size_t tbslen));
236 void EVP_PKEY_meth_get_check(const EVP_PKEY_METHOD *pmeth,
237 int (**pcheck) (EVP_PKEY *pkey));
238 void EVP_PKEY_meth_get_public_check(const EVP_PKEY_METHOD *pmeth,
239 int (**pcheck) (EVP_PKEY *pkey));
240 void EVP_PKEY_meth_get_param_check(const EVP_PKEY_METHOD *pmeth,
241 int (**pcheck) (EVP_PKEY *pkey));
242 void EVP_PKEY_meth_get_digest_custom(const EVP_PKEY_METHOD *pmeth,
243 int (**pdigest_custom) (EVP_PKEY_CTX *ctx,
244 EVP_MD_CTX *mctx));
245
247 All of the functions described on this page are deprecated.
248 Applications should instead use the OSSL_PROVIDER APIs.
249 EVP_PKEY_METHOD is a structure which holds a set of methods for a
251 specific public key cryptographic algorithm. Those methods are usually
252 used to perform different jobs, such as generating a key, signing or
253 verifying, encrypting or decrypting, etc.
254 There are two places where the EVP_PKEY_METHOD objects are stored: one
256 is a built-in static array representing the standard methods for
257 different algorithms, and the other one is a stack of user-defined
258 application-specific methods, which can be manipulated by using
259 EVP_PKEY_meth_add0(3).
260 The EVP_PKEY_METHOD objects are usually referenced by EVP_PKEY_CTX
262 objects.
263 Methods
265 The methods are the underlying implementations of a particular public
266 key algorithm present by the EVP_PKEY_CTX object.
267 int (*init) (EVP_PKEY_CTX *ctx);
269 int (*copy) (EVP_PKEY_CTX *dst, const EVP_PKEY_CTX *src);
270 void (*cleanup) (EVP_PKEY_CTX *ctx);
271 The init() method is called to initialize algorithm-specific data when
273 a new EVP_PKEY_CTX is created. As opposed to init(), the cleanup()
274 method is called when an EVP_PKEY_CTX is freed. The copy() method is
275 called when an EVP_PKEY_CTX is being duplicated. Refer to
276 EVP_PKEY_CTX_new(3), EVP_PKEY_CTX_new_id(3), EVP_PKEY_CTX_free(3) and
277 EVP_PKEY_CTX_dup(3).
278 int (*paramgen_init) (EVP_PKEY_CTX *ctx);
280 int (*paramgen) (EVP_PKEY_CTX *ctx, EVP_PKEY *pkey);
281 The paramgen_init() and paramgen() methods deal with key parameter
283 generation. They are called by EVP_PKEY_paramgen_init(3) and
284 EVP_PKEY_paramgen(3) to handle the parameter generation process.
285 int (*keygen_init) (EVP_PKEY_CTX *ctx);
287 int (*keygen) (EVP_PKEY_CTX *ctx, EVP_PKEY *pkey);
288 The keygen_init() and keygen() methods are used to generate the actual
290 key for the specified algorithm. They are called by
291 EVP_PKEY_keygen_init(3) and EVP_PKEY_keygen(3).
292 int (*sign_init) (EVP_PKEY_CTX *ctx);
294 int (*sign) (EVP_PKEY_CTX *ctx, unsigned char *sig, size_t *siglen,
295 const unsigned char *tbs, size_t tbslen);
296 The sign_init() and sign() methods are used to generate the signature
298 of a piece of data using a private key. They are called by
299 EVP_PKEY_sign_init(3) and EVP_PKEY_sign(3).
300 int (*verify_init) (EVP_PKEY_CTX *ctx);
302 int (*verify) (EVP_PKEY_CTX *ctx,
303 const unsigned char *sig, size_t siglen,
304 const unsigned char *tbs, size_t tbslen);
305 The verify_init() and verify() methods are used to verify whether a
307 signature is valid. They are called by EVP_PKEY_verify_init(3) and
308 EVP_PKEY_verify(3).
309 int (*verify_recover_init) (EVP_PKEY_CTX *ctx);
311 int (*verify_recover) (EVP_PKEY_CTX *ctx,
312 unsigned char *rout, size_t *routlen,
313 const unsigned char *sig, size_t siglen);
314 The verify_recover_init() and verify_recover() methods are used to
316 verify a signature and then recover the digest from the signature (for
317 instance, a signature that was generated by RSA signing algorithm).
318 They are called by EVP_PKEY_verify_recover_init(3) and
319 EVP_PKEY_verify_recover(3).
320 int (*signctx_init) (EVP_PKEY_CTX *ctx, EVP_MD_CTX *mctx);
322 int (*signctx) (EVP_PKEY_CTX *ctx, unsigned char *sig, size_t *siglen,
323 EVP_MD_CTX *mctx);
324 The signctx_init() and signctx() methods are used to sign a digest
326 present by a EVP_MD_CTX object. They are called by the EVP_DigestSign
327 functions. See EVP_DigestSignInit(3) for details.
328 int (*verifyctx_init) (EVP_PKEY_CTX *ctx, EVP_MD_CTX *mctx);
330 int (*verifyctx) (EVP_PKEY_CTX *ctx, const unsigned char *sig, int siglen,
331 EVP_MD_CTX *mctx);
332 The verifyctx_init() and verifyctx() methods are used to verify a
334 signature against the data in a EVP_MD_CTX object. They are called by
335 the various EVP_DigestVerify functions. See EVP_DigestVerifyInit(3) for
336 details.
337 int (*encrypt_init) (EVP_PKEY_CTX *ctx);
339 int (*encrypt) (EVP_PKEY_CTX *ctx, unsigned char *out, size_t *outlen,
340 const unsigned char *in, size_t inlen);
341 The encrypt_init() and encrypt() methods are used to encrypt a piece of
343 data. They are called by EVP_PKEY_encrypt_init(3) and
344 EVP_PKEY_encrypt(3).
345 int (*decrypt_init) (EVP_PKEY_CTX *ctx);
347 int (*decrypt) (EVP_PKEY_CTX *ctx, unsigned char *out, size_t *outlen,
348 const unsigned char *in, size_t inlen);
349 The decrypt_init() and decrypt() methods are used to decrypt a piece of
351 data. They are called by EVP_PKEY_decrypt_init(3) and
352 EVP_PKEY_decrypt(3).
353 int (*derive_init) (EVP_PKEY_CTX *ctx);
355 int (*derive) (EVP_PKEY_CTX *ctx, unsigned char *key, size_t *keylen);
356 The derive_init() and derive() methods are used to derive the shared
358 secret from a public key algorithm (for instance, the DH algorithm).
359 They are called by EVP_PKEY_derive_init(3) and EVP_PKEY_derive(3).
360 int (*ctrl) (EVP_PKEY_CTX *ctx, int type, int p1, void *p2);
362 int (*ctrl_str) (EVP_PKEY_CTX *ctx, const char *type, const char *value);
363 The ctrl() and ctrl_str() methods are used to adjust algorithm-specific
365 settings. See EVP_PKEY_CTX_ctrl(3) and related functions for details.
366 int (*digestsign) (EVP_MD_CTX *ctx, unsigned char *sig, size_t *siglen,
368 const unsigned char *tbs, size_t tbslen);
369 int (*digestverify) (EVP_MD_CTX *ctx, const unsigned char *sig,
370 size_t siglen, const unsigned char *tbs,
371 size_t tbslen);
372 The digestsign() and digestverify() methods are used to generate or
374 verify a signature in a one-shot mode. They could be called by
375 EVP_DigestSign(3) and EVP_DigestVerify(3).
376 int (*check) (EVP_PKEY *pkey);
378 int (*public_check) (EVP_PKEY *pkey);
379 int (*param_check) (EVP_PKEY *pkey);
380 The check(), public_check() and param_check() methods are used to
382 validate a key-pair, the public component and parameters respectively
383 for a given pkey. They could be called by EVP_PKEY_check(3),
384 EVP_PKEY_public_check(3) and EVP_PKEY_param_check(3) respectively.
385 int (*digest_custom) (EVP_PKEY_CTX *ctx, EVP_MD_CTX *mctx);
387 The digest_custom() method is used to generate customized digest
389 content before the real message is passed to functions like
390 EVP_DigestSignUpdate(3) or EVP_DigestVerifyInit(3). This is usually
391 required by some public key signature algorithms like SM2 which
392 requires a hashed prefix to the message to be signed. The
393 digest_custom() function will be called by EVP_DigestSignInit(3) and
394 EVP_DigestVerifyInit(3).
395 Functions
397 EVP_PKEY_meth_new() creates and returns a new EVP_PKEY_METHOD object,
398 and associates the given id and flags. The following flags are
399 supported:
400 EVP_PKEY_FLAG_AUTOARGLEN
402 EVP_PKEY_FLAG_SIGCTX_CUSTOM
403 If an EVP_PKEY_METHOD is set with the EVP_PKEY_FLAG_AUTOARGLEN flag,
405 the maximum size of the output buffer will be automatically calculated
406 or checked in corresponding EVP methods by the EVP framework. Thus the
407 implementations of these methods don't need to care about handling the
408 case of returning output buffer size by themselves. For details on the
409 output buffer size, refer to EVP_PKEY_sign(3).
410 The EVP_PKEY_FLAG_SIGCTX_CUSTOM is used to indicate the signctx()
412 method of an EVP_PKEY_METHOD is always called by the EVP framework
413 while doing a digest signing operation by calling
414 EVP_DigestSignFinal(3).
415 EVP_PKEY_meth_free() frees an existing EVP_PKEY_METHOD pointed by
417 pmeth.
418 EVP_PKEY_meth_copy() copies an EVP_PKEY_METHOD object from src to dst.
420 EVP_PKEY_meth_find() finds an EVP_PKEY_METHOD object with the id. This
422 function first searches through the user-defined method objects and
423 then the built-in objects.
424 EVP_PKEY_meth_add0() adds pmeth to the user defined stack of methods.
426 EVP_PKEY_meth_remove() removes an EVP_PKEY_METHOD object added by
428 EVP_PKEY_meth_add0().
429 The EVP_PKEY_meth_set functions set the corresponding fields of
431 EVP_PKEY_METHOD structure with the arguments passed.
432 The EVP_PKEY_meth_get functions get the corresponding fields of
434 EVP_PKEY_METHOD structure to the arguments provided.
435
437 EVP_PKEY_meth_new() returns a pointer to a new EVP_PKEY_METHOD object
438 or returns NULL on error.
439 EVP_PKEY_meth_free() and EVP_PKEY_meth_copy() do not return values.
441 EVP_PKEY_meth_find() returns a pointer to the found EVP_PKEY_METHOD
443 object or returns NULL if not found.
444 EVP_PKEY_meth_add0() returns 1 if method is added successfully or 0 if
446 an error occurred.
447 EVP_PKEY_meth_remove() returns 1 if method is removed successfully or 0
449 if an error occurred.
450 All EVP_PKEY_meth_set and EVP_PKEY_meth_get functions have no return
452 values. For the 'get' functions, function pointers are returned by
453 arguments.
454
456 All of these functions were deprecated in OpenSSL 3.0.
457 The signature of the copy functional argument of
459 EVP_PKEY_meth_set_copy() has changed in OpenSSL 3.0 so its src
460 parameter is now constified.
461
463 Copyright 2017-2021 The OpenSSL Project Authors. All Rights Reserved.
464 Licensed under the Apache License 2.0 (the "License"). You may not use
466 this file except in compliance with the License. You can obtain a copy
467 in the file LICENSE in the source distribution or at
468 <https://www.openssl.org/source/license.html>.
4693.1.1 2023-08-31 EVP_PKEY_METH_NEW(3ossl)