1EVP_PKEY_meth_new(3) OpenSSL EVP_PKEY_meth_new(3)
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_get_init, EVP_PKEY_meth_get_copy,
16 EVP_PKEY_meth_get_cleanup, EVP_PKEY_meth_get_paramgen,
17 EVP_PKEY_meth_get_keygen, EVP_PKEY_meth_get_sign,
18 EVP_PKEY_meth_get_verify, EVP_PKEY_meth_get_verify_recover,
19 EVP_PKEY_meth_get_signctx, EVP_PKEY_meth_get_verifyctx,
20 EVP_PKEY_meth_get_encrypt, EVP_PKEY_meth_get_decrypt,
21 EVP_PKEY_meth_get_derive, EVP_PKEY_meth_get_ctrl - manipulating
22 EVP_PKEY_METHOD structure
23
25 #include <openssl/evp.h>
26 typedef struct evp_pkey_method_st EVP_PKEY_METHOD;
28 EVP_PKEY_METHOD *EVP_PKEY_meth_new(int id, int flags);
30 void EVP_PKEY_meth_free(EVP_PKEY_METHOD *pmeth);
31 void EVP_PKEY_meth_copy(EVP_PKEY_METHOD *dst, const EVP_PKEY_METHOD *src);
32 const EVP_PKEY_METHOD *EVP_PKEY_meth_find(int type);
33 int EVP_PKEY_meth_add0(const EVP_PKEY_METHOD *pmeth);
34 void EVP_PKEY_meth_set_init(EVP_PKEY_METHOD *pmeth,
36 int (*init) (EVP_PKEY_CTX *ctx));
37 void EVP_PKEY_meth_set_copy(EVP_PKEY_METHOD *pmeth,
38 int (*copy) (EVP_PKEY_CTX *dst,
39 EVP_PKEY_CTX *src));
40 void EVP_PKEY_meth_set_cleanup(EVP_PKEY_METHOD *pmeth,
41 void (*cleanup) (EVP_PKEY_CTX *ctx));
42 void EVP_PKEY_meth_set_paramgen(EVP_PKEY_METHOD *pmeth,
43 int (*paramgen_init) (EVP_PKEY_CTX *ctx),
44 int (*paramgen) (EVP_PKEY_CTX *ctx,
45 EVP_PKEY *pkey));
46 void EVP_PKEY_meth_set_keygen(EVP_PKEY_METHOD *pmeth,
47 int (*keygen_init) (EVP_PKEY_CTX *ctx),
48 int (*keygen) (EVP_PKEY_CTX *ctx,
49 EVP_PKEY *pkey));
50 void EVP_PKEY_meth_set_sign(EVP_PKEY_METHOD *pmeth,
51 int (*sign_init) (EVP_PKEY_CTX *ctx),
52 int (*sign) (EVP_PKEY_CTX *ctx,
53 unsigned char *sig, size_t *siglen,
54 const unsigned char *tbs,
55 size_t tbslen));
56 void EVP_PKEY_meth_set_verify(EVP_PKEY_METHOD *pmeth,
57 int (*verify_init) (EVP_PKEY_CTX *ctx),
58 int (*verify) (EVP_PKEY_CTX *ctx,
59 const unsigned char *sig,
60 size_t siglen,
61 const unsigned char *tbs,
62 size_t tbslen));
63 void EVP_PKEY_meth_set_verify_recover(EVP_PKEY_METHOD *pmeth,
64 int (*verify_recover_init) (EVP_PKEY_CTX
65 *ctx),
66 int (*verify_recover) (EVP_PKEY_CTX
67 *ctx,
68 unsigned char
69 *sig,
70 size_t *siglen,
71 const unsigned
72 char *tbs,
73 size_t tbslen));
74 void EVP_PKEY_meth_set_signctx(EVP_PKEY_METHOD *pmeth,
75 int (*signctx_init) (EVP_PKEY_CTX *ctx,
76 EVP_MD_CTX *mctx),
77 int (*signctx) (EVP_PKEY_CTX *ctx,
78 unsigned char *sig,
79 size_t *siglen,
80 EVP_MD_CTX *mctx));
81 void EVP_PKEY_meth_set_verifyctx(EVP_PKEY_METHOD *pmeth,
82 int (*verifyctx_init) (EVP_PKEY_CTX *ctx,
83 EVP_MD_CTX *mctx),
84 int (*verifyctx) (EVP_PKEY_CTX *ctx,
85 const unsigned char *sig,
86 int siglen,
87 EVP_MD_CTX *mctx));
88 void EVP_PKEY_meth_set_encrypt(EVP_PKEY_METHOD *pmeth,
89 int (*encrypt_init) (EVP_PKEY_CTX *ctx),
90 int (*encryptfn) (EVP_PKEY_CTX *ctx,
91 unsigned char *out,
92 size_t *outlen,
93 const unsigned char *in,
94 size_t inlen));
95 void EVP_PKEY_meth_set_decrypt(EVP_PKEY_METHOD *pmeth,
96 int (*decrypt_init) (EVP_PKEY_CTX *ctx),
97 int (*decrypt) (EVP_PKEY_CTX *ctx,
98 unsigned char *out,
99 size_t *outlen,
100 const unsigned char *in,
101 size_t inlen));
102 void EVP_PKEY_meth_set_derive(EVP_PKEY_METHOD *pmeth,
103 int (*derive_init) (EVP_PKEY_CTX *ctx),
104 int (*derive) (EVP_PKEY_CTX *ctx,
105 unsigned char *key,
106 size_t *keylen));
107 void EVP_PKEY_meth_set_ctrl(EVP_PKEY_METHOD *pmeth,
108 int (*ctrl) (EVP_PKEY_CTX *ctx, int type, int p1,
109 void *p2),
110 int (*ctrl_str) (EVP_PKEY_CTX *ctx,
111 const char *type,
112 const char *value));
113 void EVP_PKEY_meth_get_init(EVP_PKEY_METHOD *pmeth,
115 int (**pinit) (EVP_PKEY_CTX *ctx));
116 void EVP_PKEY_meth_get_copy(EVP_PKEY_METHOD *pmeth,
117 int (**pcopy) (EVP_PKEY_CTX *dst,
118 EVP_PKEY_CTX *src));
119 void EVP_PKEY_meth_get_cleanup(EVP_PKEY_METHOD *pmeth,
120 void (**pcleanup) (EVP_PKEY_CTX *ctx));
121 void EVP_PKEY_meth_get_paramgen(EVP_PKEY_METHOD *pmeth,
122 int (**pparamgen_init) (EVP_PKEY_CTX *ctx),
123 int (**pparamgen) (EVP_PKEY_CTX *ctx,
124 EVP_PKEY *pkey));
125 void EVP_PKEY_meth_get_keygen(EVP_PKEY_METHOD *pmeth,
126 int (**pkeygen_init) (EVP_PKEY_CTX *ctx),
127 int (**pkeygen) (EVP_PKEY_CTX *ctx,
128 EVP_PKEY *pkey));
129 void EVP_PKEY_meth_get_sign(EVP_PKEY_METHOD *pmeth,
130 int (**psign_init) (EVP_PKEY_CTX *ctx),
131 int (**psign) (EVP_PKEY_CTX *ctx,
132 unsigned char *sig, size_t *siglen,
133 const unsigned char *tbs,
134 size_t tbslen));
135 void EVP_PKEY_meth_get_verify(EVP_PKEY_METHOD *pmeth,
136 int (**pverify_init) (EVP_PKEY_CTX *ctx),
137 int (**pverify) (EVP_PKEY_CTX *ctx,
138 const unsigned char *sig,
139 size_t siglen,
140 const unsigned char *tbs,
141 size_t tbslen));
142 void EVP_PKEY_meth_get_verify_recover(EVP_PKEY_METHOD *pmeth,
143 int (**pverify_recover_init) (EVP_PKEY_CTX
144 *ctx),
145 int (**pverify_recover) (EVP_PKEY_CTX
146 *ctx,
147 unsigned char
148 *sig,
149 size_t *siglen,
150 const unsigned
151 char *tbs,
152 size_t tbslen));
153 void EVP_PKEY_meth_get_signctx(EVP_PKEY_METHOD *pmeth,
154 int (**psignctx_init) (EVP_PKEY_CTX *ctx,
155 EVP_MD_CTX *mctx),
156 int (**psignctx) (EVP_PKEY_CTX *ctx,
157 unsigned char *sig,
158 size_t *siglen,
159 EVP_MD_CTX *mctx));
160 void EVP_PKEY_meth_get_verifyctx(EVP_PKEY_METHOD *pmeth,
161 int (**pverifyctx_init) (EVP_PKEY_CTX *ctx,
162 EVP_MD_CTX *mctx),
163 int (**pverifyctx) (EVP_PKEY_CTX *ctx,
164 const unsigned char *sig,
165 int siglen,
166 EVP_MD_CTX *mctx));
167 void EVP_PKEY_meth_get_encrypt(EVP_PKEY_METHOD *pmeth,
168 int (**pencrypt_init) (EVP_PKEY_CTX *ctx),
169 int (**pencryptfn) (EVP_PKEY_CTX *ctx,
170 unsigned char *out,
171 size_t *outlen,
172 const unsigned char *in,
173 size_t inlen));
174 void EVP_PKEY_meth_get_decrypt(EVP_PKEY_METHOD *pmeth,
175 int (**pdecrypt_init) (EVP_PKEY_CTX *ctx),
176 int (**pdecrypt) (EVP_PKEY_CTX *ctx,
177 unsigned char *out,
178 size_t *outlen,
179 const unsigned char *in,
180 size_t inlen));
181 void EVP_PKEY_meth_get_derive(EVP_PKEY_METHOD *pmeth,
182 int (**pderive_init) (EVP_PKEY_CTX *ctx),
183 int (**pderive) (EVP_PKEY_CTX *ctx,
184 unsigned char *key,
185 size_t *keylen));
186 void EVP_PKEY_meth_get_ctrl(EVP_PKEY_METHOD *pmeth,
187 int (**pctrl) (EVP_PKEY_CTX *ctx, int type, int p1,
188 void *p2),
189 int (**pctrl_str) (EVP_PKEY_CTX *ctx,
190 const char *type,
191 const char *value));
192
194 EVP_PKEY_METHOD is a structure which holds a set of methods for a
195 specific public key cryptographic algorithm. Those methods are usually
196 used to perform different jobs, such as generating a key, signing or
197 verifying, encrypting or decrypting, etc.
198 There are two places where the EVP_PKEY_METHOD objects are stored: one
200 is a built-in static array representing the standard methods for
201 different algorithms, and the other one is a stack of user-defined
202 application-specific methods, which can be manipulated by using
203 EVP_PKEY_meth_add0(3).
204 The EVP_PKEY_METHOD objects are usually referenced by EVP_PKEY_CTX
206 objects.
207 Methods
209 The methods are the underlying implementations of a particular public
210 key algorithm present by the EVP_PKEY_CTX object.
211 int (*init) (EVP_PKEY_CTX *ctx);
213 int (*copy) (EVP_PKEY_CTX *dst, EVP_PKEY_CTX *src);
214 void (*cleanup) (EVP_PKEY_CTX *ctx);
215 The init() method is called to initialize algorithm-specific data when
217 a new EVP_PKEY_CTX is created. As opposed to init(), the cleanup()
218 method is called when an EVP_PKEY_CTX is freed. The copy() method is
219 called when an EVP_PKEY_CTX is being duplicated. Refer to
220 EVP_PKEY_CTX_new(3), EVP_PKEY_CTX_new_id(3), EVP_PKEY_CTX_free(3) and
221 EVP_PKEY_CTX_dup(3).
222 int (*paramgen_init) (EVP_PKEY_CTX *ctx);
224 int (*paramgen) (EVP_PKEY_CTX *ctx, EVP_PKEY *pkey);
225 The paramgen_init() and paramgen() methods deal with key parameter
227 generation. They are called by EVP_PKEY_paramgen_init(3) and
228 EVP_PKEY_paramgen(3) to handle the parameter generation process.
229 int (*keygen_init) (EVP_PKEY_CTX *ctx);
231 int (*keygen) (EVP_PKEY_CTX *ctx, EVP_PKEY *pkey);
232 The keygen_init() and keygen() methods are used to generate the actual
234 key for the specified algorithm. They are called by
235 EVP_PKEY_keygen_init(3) and EVP_PKEY_keygen(3).
236 int (*sign_init) (EVP_PKEY_CTX *ctx);
238 int (*sign) (EVP_PKEY_CTX *ctx, unsigned char *sig, size_t *siglen,
239 const unsigned char *tbs, size_t tbslen);
240 The sign_init() and sign() methods are used to generate the signature
242 of a piece of data using a private key. They are called by
243 EVP_PKEY_sign_init(3) and EVP_PKEY_sign(3).
244 int (*verify_init) (EVP_PKEY_CTX *ctx);
246 int (*verify) (EVP_PKEY_CTX *ctx,
247 const unsigned char *sig, size_t siglen,
248 const unsigned char *tbs, size_t tbslen);
249 The verify_init() and verify() methods are used to verify whether a
251 signature is valid. They are called by EVP_PKEY_verify_init(3) and
252 EVP_PKEY_verify(3).
253 int (*verify_recover_init) (EVP_PKEY_CTX *ctx);
255 int (*verify_recover) (EVP_PKEY_CTX *ctx,
256 unsigned char *rout, size_t *routlen,
257 const unsigned char *sig, size_t siglen);
258 The verify_recover_init() and verify_recover() methods are used to
260 verify a signature and then recover the digest from the signature (for
261 instance, a signature that was generated by RSA signing algorithm).
262 They are called by EVP_PKEY_verify_recover_init(3) and
263 EVP_PKEY_verify_recover(3).
264 int (*signctx_init) (EVP_PKEY_CTX *ctx, EVP_MD_CTX *mctx);
266 int (*signctx) (EVP_PKEY_CTX *ctx, unsigned char *sig, size_t *siglen,
267 EVP_MD_CTX *mctx);
268 The signctx_init() and signctx() methods are used to sign a digest
270 present by a EVP_MD_CTX object. They are called by the EVP_DigestSign
271 functions. See EVP_DigestSignInit(3) for detail.
272 int (*verifyctx_init) (EVP_PKEY_CTX *ctx, EVP_MD_CTX *mctx);
274 int (*verifyctx) (EVP_PKEY_CTX *ctx, const unsigned char *sig, int siglen,
275 EVP_MD_CTX *mctx);
276 The verifyctx_init() and verifyctx() methods are used to verify a
278 signature against the data in a EVP_MD_CTX object. They are called by
279 the various EVP_DigestVerify functions. See EVP_DigestVerifyInit(3) for
280 detail.
281 int (*encrypt_init) (EVP_PKEY_CTX *ctx);
283 int (*encrypt) (EVP_PKEY_CTX *ctx, unsigned char *out, size_t *outlen,
284 const unsigned char *in, size_t inlen);
285 The encrypt_init() and encrypt() methods are used to encrypt a piece of
287 data. They are called by EVP_PKEY_encrypt_init(3) and
288 EVP_PKEY_encrypt(3).
289 int (*decrypt_init) (EVP_PKEY_CTX *ctx);
291 int (*decrypt) (EVP_PKEY_CTX *ctx, unsigned char *out, size_t *outlen,
292 const unsigned char *in, size_t inlen);
293 The decrypt_init() and decrypt() methods are used to decrypt a piece of
295 data. They are called by EVP_PKEY_decrypt_init(3) and
296 EVP_PKEY_decrypt(3).
297 int (*derive_init) (EVP_PKEY_CTX *ctx);
299 int (*derive) (EVP_PKEY_CTX *ctx, unsigned char *key, size_t *keylen);
300 The derive_init() and derive() methods are used to derive the shared
302 secret from a public key algorithm (for instance, the DH algorithm).
303 They are called by EVP_PKEY_derive_init(3) and EVP_PKEY_derive(3).
304 int (*ctrl) (EVP_PKEY_CTX *ctx, int type, int p1, void *p2);
306 int (*ctrl_str) (EVP_PKEY_CTX *ctx, const char *type, const char *value);
307 The ctrl() and ctrl_str() methods are used to adjust algorithm-specific
309 settings. See EVP_PKEY_CTX_ctrl(3) and related functions for detail.
310 int (*digestsign) (EVP_MD_CTX *ctx, unsigned char *sig, size_t *siglen,
312 const unsigned char *tbs, size_t tbslen);
313 int (*digestverify) (EVP_MD_CTX *ctx, const unsigned char *sig,
314 size_t siglen, const unsigned char *tbs,
315 size_t tbslen);
316 The digestsign() and digestverify() methods are used to generate or
318 verify a signature in a one-shot mode. They could be called by
319 EVP_DigetSign(3) and EVP_DigestVerify(3).
320 Functions
322 EVP_PKEY_meth_new() creates and returns a new EVP_PKEY_METHOD object,
323 and associates the given id and flags. The following flags are
324 supported:
325 EVP_PKEY_FLAG_AUTOARGLEN
327 EVP_PKEY_FLAG_SIGCTX_CUSTOM
328 If an EVP_PKEY_METHOD is set with the EVP_PKEY_FLAG_AUTOARGLEN flag,
330 the maximum size of the output buffer will be automatically calculated
331 or checked in corresponding EVP methods by the EVP framework. Thus the
332 implementations of these methods don't need to care about handling the
333 case of returning output buffer size by themselves. For details on the
334 output buffer size, refer to EVP_PKEY_sign(3).
335 The EVP_PKEY_FLAG_SIGCTX_CUSTOM is used to indicate the signctx()
337 method of an EVP_PKEY_METHOD is always called by the EVP framework
338 while doing a digest signing operation by calling
339 EVP_DigestSignFinal(3).
340 EVP_PKEY_meth_free() frees an existing EVP_PKEY_METHOD pointed by
342 pmeth.
343 EVP_PKEY_meth_copy() copies an EVP_PKEY_METHOD object from src to dst.
345 EVP_PKEY_meth_find() finds an EVP_PKEY_METHOD object with the id. This
347 function first searches through the user-defined method objects and
348 then the built-in objects.
349 EVP_PKEY_meth_add0() adds pmeth to the user defined stack of methods.
351 The EVP_PKEY_meth_set functions set the corresponding fields of
353 EVP_PKEY_METHOD structure with the arguments passed.
354 The EVP_PKEY_meth_get functions get the corresponding fields of
356 EVP_PKEY_METHOD structure to the arguments provided.
357
359 EVP_PKEY_meth_new() returns a pointer to a new EVP_PKEY_METHOD object
360 or returns NULL on error.
361 EVP_PKEY_meth_free() and EVP_PKEY_meth_copy() do not return values.
363 EVP_PKEY_meth_find() returns a pointer to the found EVP_PKEY_METHOD
365 object or returns NULL if not found.
366 EVP_PKEY_meth_add0() returns 1 if method is added successfully or 0 if
368 an error occurred.
369 All EVP_PKEY_meth_set and EVP_PKEY_meth_get functions have no return
371 values. For the 'get' functions, function pointers are returned by
372 arguments.
373
375 Copyright 2017 The OpenSSL Project Authors. All Rights Reserved.
376 Licensed under the OpenSSL license (the "License"). You may not use
378 this file except in compliance with the License. You can obtain a copy
379 in the file LICENSE in the source distribution or at
380 <https://www.openssl.org/source/license.html>.
3811.0.2o 2020-08-01 EVP_PKEY_meth_new(3)