1EVP_PKEY_METH_NEW(3ossl)            OpenSSL           EVP_PKEY_METH_NEW(3ossl)
2
3
4

NAME

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

SYNOPSIS

31        #include <openssl/evp.h>
32
33       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
37        typedef struct evp_pkey_method_st EVP_PKEY_METHOD;
38
39        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
46        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
146        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

DESCRIPTION

247       All of the functions described on this page are deprecated.
248       Applications should instead use the OSSL_PROVIDER APIs.
249
250       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
255       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
261       The EVP_PKEY_METHOD objects are usually referenced by EVP_PKEY_CTX
262       objects.
263
264   Methods
265       The methods are the underlying implementations of a particular public
266       key algorithm present by the EVP_PKEY_CTX object.
267
268        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
272       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
279        int (*paramgen_init) (EVP_PKEY_CTX *ctx);
280        int (*paramgen) (EVP_PKEY_CTX *ctx, EVP_PKEY *pkey);
281
282       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
286        int (*keygen_init) (EVP_PKEY_CTX *ctx);
287        int (*keygen) (EVP_PKEY_CTX *ctx, EVP_PKEY *pkey);
288
289       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
293        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
297       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
301        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
306       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
310        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
315       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
321        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
325       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
329        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
333       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
338        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
342       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
346        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
350       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
354        int (*derive_init) (EVP_PKEY_CTX *ctx);
355        int (*derive) (EVP_PKEY_CTX *ctx, unsigned char *key, size_t *keylen);
356
357       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
361        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
364       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
367        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
373       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
377        int (*check) (EVP_PKEY *pkey);
378        int (*public_check) (EVP_PKEY *pkey);
379        int (*param_check) (EVP_PKEY *pkey);
380
381       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
386        int (*digest_custom) (EVP_PKEY_CTX *ctx, EVP_MD_CTX *mctx);
387
388       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
396   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
401        EVP_PKEY_FLAG_AUTOARGLEN
402        EVP_PKEY_FLAG_SIGCTX_CUSTOM
403
404       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
411       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
416       EVP_PKEY_meth_free() frees an existing EVP_PKEY_METHOD pointed by
417       pmeth.
418
419       EVP_PKEY_meth_copy() copies an EVP_PKEY_METHOD object from src to dst.
420
421       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
425       EVP_PKEY_meth_add0() adds pmeth to the user defined stack of methods.
426
427       EVP_PKEY_meth_remove() removes an EVP_PKEY_METHOD object added by
428       EVP_PKEY_meth_add0().
429
430       The EVP_PKEY_meth_set functions set the corresponding fields of
431       EVP_PKEY_METHOD structure with the arguments passed.
432
433       The EVP_PKEY_meth_get functions get the corresponding fields of
434       EVP_PKEY_METHOD structure to the arguments provided.
435

RETURN VALUES

437       EVP_PKEY_meth_new() returns a pointer to a new EVP_PKEY_METHOD object
438       or returns NULL on error.
439
440       EVP_PKEY_meth_free() and EVP_PKEY_meth_copy() do not return values.
441
442       EVP_PKEY_meth_find() returns a pointer to the found EVP_PKEY_METHOD
443       object or returns NULL if not found.
444
445       EVP_PKEY_meth_add0() returns 1 if method is added successfully or 0 if
446       an error occurred.
447
448       EVP_PKEY_meth_remove() returns 1 if method is removed successfully or 0
449       if an error occurred.
450
451       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

HISTORY

456       All of these functions were deprecated in OpenSSL 3.0.
457
458       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
465       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>.
469
470
471
4723.0.5                             2022-07-05          EVP_PKEY_METH_NEW(3ossl)
Impressum