EVP_PKEY_METH_NEW(3SSL)
💅 NAME 💅
okay so this page is literally the whole EVP_PKEY_METHOD squad — every new/free/copy/find/add0/remove bestie and all the set_* and get_* accessor girlies that poke at the struct fields. it's giving "one page, forty-eight functions, zero chill." 🫶
the main characters:
EVP_PKEY_meth_newEVP_PKEY_meth_freeEVP_PKEY_meth_copyEVP_PKEY_meth_findEVP_PKEY_meth_add0EVP_PKEY_METHOD← the type itself, yes she countsEVP_PKEY_meth_set_initEVP_PKEY_meth_set_copyEVP_PKEY_meth_set_cleanupEVP_PKEY_meth_set_paramgenEVP_PKEY_meth_set_keygenEVP_PKEY_meth_set_signEVP_PKEY_meth_set_verifyEVP_PKEY_meth_set_verify_recoverEVP_PKEY_meth_set_signctxEVP_PKEY_meth_set_verifyctxEVP_PKEY_meth_set_encryptEVP_PKEY_meth_set_decryptEVP_PKEY_meth_set_deriveEVP_PKEY_meth_set_ctrlEVP_PKEY_meth_set_digestsignEVP_PKEY_meth_set_digestverifyEVP_PKEY_meth_set_checkEVP_PKEY_meth_set_public_checkEVP_PKEY_meth_set_param_checkEVP_PKEY_meth_set_digest_customEVP_PKEY_meth_get_initEVP_PKEY_meth_get_copyEVP_PKEY_meth_get_cleanupEVP_PKEY_meth_get_paramgenEVP_PKEY_meth_get_keygenEVP_PKEY_meth_get_signEVP_PKEY_meth_get_verifyEVP_PKEY_meth_get_verify_recoverEVP_PKEY_meth_get_signctxEVP_PKEY_meth_get_verifyctxEVP_PKEY_meth_get_encryptEVP_PKEY_meth_get_decryptEVP_PKEY_meth_get_deriveEVP_PKEY_meth_get_ctrlEVP_PKEY_meth_get_digestsignEVP_PKEY_meth_get_digestverifyEVP_PKEY_meth_get_checkEVP_PKEY_meth_get_public_checkEVP_PKEY_meth_get_param_checkEVP_PKEY_meth_get_digest_customEVP_PKEY_meth_remove
and what are they all about? manipulating EVP_PKEY_METHOD structure. that's it. that's the vibe. 💅
✨ SYNOPSIS ✨
first things first, the include, no cap:
#include <openssl/evp.h>⚠️ okay bestie, sit down. all of the functions below have been deprecated since OpenSSL 3.0, and you can hide them entirely by definingOPENSSL_API_COMPATwith a suitable version value — seeopenssl_user_macros(7)for the deets. deprecated doesn't mean deleted, it means "she's still here but the library wants you to move on." 😭
the type, she's a typedef and she's iconic:
typedef struct evp_pkey_method_st EVP_PKEY_METHOD;the lifecycle / registry crew 🔥:
EVP_PKEY_METHOD *EVP_PKEY_meth_new(int id, int flags);
void EVP_PKEY_meth_free(EVP_PKEY_METHOD *pmeth);
void EVP_PKEY_meth_copy(EVP_PKEY_METHOD *dst, const EVP_PKEY_METHOD *src);
const EVP_PKEY_METHOD *EVP_PKEY_meth_find(int type);
int EVP_PKEY_meth_add0(const EVP_PKEY_METHOD *pmeth);
int EVP_PKEY_meth_remove(const EVP_PKEY_METHOD *pmeth);and now the setter era, where every single function hands the struct a callback pointer like it's passing notes in class 🎀:
void EVP_PKEY_meth_set_init(EVP_PKEY_METHOD *pmeth,
int (*init) (EVP_PKEY_CTX *ctx));
void EVP_PKEY_meth_set_copy(EVP_PKEY_METHOD *pmeth,
int (*copy) (EVP_PKEY_CTX *dst,
const EVP_PKEY_CTX *src));
void EVP_PKEY_meth_set_cleanup(EVP_PKEY_METHOD *pmeth,
void (*cleanup) (EVP_PKEY_CTX *ctx));
void 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));
void 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));
void 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));
void 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));verify_recover is lowkey the messy one — look at how the man page wraps her, she simply refuses to fit, and honestly? same. ✨
void 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));the *ctx variants, for when you're signing/verifying through an EVP_MD_CTX instead of raw bytes 🌸:
void 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));
void 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));note the vibe check: signctx takes size_t *siglen but verifyctx takes a plain int siglen. not me pointing that out. 💀
encrypt / decrypt / derive, the classic trio 🦋:
void 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));
void 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));
void 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));ctrl time — one takes an int type and a void *p2, the other takes actual strings, because why be consistent when you can be ✨eclectic✨:
void 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));the digest-sign fast path besties 👑:
void EVP_PKEY_meth_set_digestsign(EVP_PKEY_METHOD *pmeth,
int (*digestsign) (EVP_MD_CTX *ctx,
unsigned char *sig,
size_t *siglen,
const unsigned char *tbs,
size_t tbslen));
void EVP_PKEY_meth_set_digestverify(EVP_PKEY_METHOD *pmeth,
int (*digestverify) (EVP_MD_CTX *ctx,
const unsigned char *sig,
size_t siglen,
const unsigned char *tbs,
size_t tbslen));and the three checks, all of which literally take the same int (*check) (EVP_PKEY *pkey) signature but mean different things, which is giving "same outfit, different font" 💜:
void EVP_PKEY_meth_set_check(EVP_PKEY_METHOD *pmeth,
int (*check) (EVP_PKEY *pkey));
void EVP_PKEY_meth_set_public_check(EVP_PKEY_METHOD *pmeth,
int (*check) (EVP_PKEY *pkey));
void EVP_PKEY_meth_set_param_check(EVP_PKEY_METHOD *pmeth,
int (*check) (EVP_PKEY *pkey));last but not least, the custom digest hook, wrapped in the man page's signature slightly-off indentation and all 🧚:
void EVP_PKEY_meth_set_digest_custom(EVP_PKEY_METHOD *pmeth,
int (*digest_custom) (EVP_PKEY_CTX *ctx,
EVP_MD_CTX *mctx));that's the whole synopsis, and yeah — there's more coming, don't go anywhere 💖
void EVP_PKEY_meth_get_init(const EVP_PKEY_METHOD *pmeth,
int (**pinit) (EVP_PKEY_CTX *ctx));
void EVP_PKEY_meth_get_copy(const EVP_PKEY_METHOD *pmeth,
int (**pcopy) (EVP_PKEY_CTX *dst,
EVP_PKEY_CTX *src));
void EVP_PKEY_meth_get_cleanup(const EVP_PKEY_METHOD *pmeth,
void (**pcleanup) (EVP_PKEY_CTX *ctx));
void EVP_PKEY_meth_get_paramgen(const EVP_PKEY_METHOD *pmeth,
int (**pparamgen_init) (EVP_PKEY_CTX *ctx),
int (**pparamgen) (EVP_PKEY_CTX *ctx,
EVP_PKEY *pkey));
void EVP_PKEY_meth_get_keygen(const EVP_PKEY_METHOD *pmeth,
int (**pkeygen_init) (EVP_PKEY_CTX *ctx),
int (**pkeygen) (EVP_PKEY_CTX *ctx,
EVP_PKEY *pkey));
void EVP_PKEY_meth_get_sign(const 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));
void EVP_PKEY_meth_get_verify(const 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));
void EVP_PKEY_meth_get_verify_recover(const 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));
void EVP_PKEY_meth_get_signctx(const 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));
void EVP_PKEY_meth_get_verifyctx(const 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));
void EVP_PKEY_meth_get_encrypt(const 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));
void EVP_PKEY_meth_get_decrypt(const 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));
void EVP_PKEY_meth_get_derive(const EVP_PKEY_METHOD *pmeth,
int (**pderive_init) (EVP_PKEY_CTX *ctx),
int (**pderive) (EVP_PKEY_CTX *ctx,
unsigned char *key,
size_t *keylen));
void EVP_PKEY_meth_get_ctrl(const 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));
void EVP_PKEY_meth_get_digestsign(const EVP_PKEY_METHOD *pmeth,
int (**digestsign) (EVP_MD_CTX *ctx,
unsigned char *sig,
size_t *siglen,
const unsigned char *tbs,
size_t tbslen));
void EVP_PKEY_meth_get_digestverify(const EVP_PKEY_METHOD *pmeth,
int (**digestverify) (EVP_MD_CTX *ctx,
const unsigned char *sig,
size_t siglen,
const unsigned char *tbs,
size_t tbslen));
void EVP_PKEY_meth_get_check(const EVP_PKEY_METHOD *pmeth,
int (**pcheck) (EVP_PKEY *pkey));
void EVP_PKEY_meth_get_public_check(const EVP_PKEY_METHOD *pmeth,
int (**pcheck) (EVP_PKEY *pkey));
void EVP_PKEY_meth_get_param_check(const EVP_PKEY_METHOD *pmeth,
int (**pcheck) (EVP_PKEY *pkey));
void EVP_PKEY_meth_get_digest_custom(const EVP_PKEY_METHOD *pmeth,
int (**pdigest_custom) (EVP_PKEY_CTX *ctx,
EVP_MD_CTX *mctx));okay so that's the whole getter squad 🫶 — every EVP_PKEY_meth_get_* in the building, all lined up. And yes bestie, they are long. Like, aggressively long. That's not a typo, that's just what it takes to hand you back a function pointer through a pointer-to-pointer 😭
Notice the pattern though — it's giving mirror image ✨ every setter has a getter, and the getters hand you back two things at a time whenever there's an init/do pair (init + the actual fn). Iconic symmetry, no notes.
We are so not done yet — keep scrolling, the next part has the actual meat 🍓
💅 DESCRIPTION 💅
okay bestie, big disclaimer before literally anything else: all of the functions described on this page are deprecated. 🫠 Like, every single one. Applications should instead use the OSSL_PROVIDER APIs. Not me delivering bad news in the first sentence but here we are 💀
So. EVP_PKEY_METHOD is a struct that holds a whole set of methods for one specific public key cryptographic algorithm. Those methods are the lil workers that do the different jobs — generating a key, signing or verifying, encrypting or decrypting, all of it.
There are two places where the EVP_PKEY_METHOD objects live:
- one is a built-in static array that represents the standard methods for different algorithms 🏛️
- the other is a stack of user-defined, application-specific methods — and you can poke at that one using
EVP_PKEY_meth_add0(3)🧚
And the EVP_PKEY_METHOD objects are usually referenced by EVP_PKEY_CTX objects. bestie energy: the CTX is the main character, the METHOD is the personality ✨
🛠️ Methods 🛠️
these are the underlying implementations of a particular public key algorithm that the EVP_PKEY_CTX object is presenting. let's go through them one by one, no skipping, we're being thorough today 💖
int (*init) (EVP_PKEY_CTX *ctx);
int (*copy) (EVP_PKEY_CTX *dst, const EVP_PKEY_CTX *src);
void (*cleanup) (EVP_PKEY_CTX *ctx);The init() method gets called to initialize algorithm-specific data whenever a new EVP_PKEY_CTX is created. And unlike init(), the cleanup() method gets called when an EVP_PKEY_CTX is freed. The copy() method? That one's called when an EVP_PKEY_CTX is being duplicated. Go read EVP_PKEY_CTX_new(3), EVP_PKEY_CTX_new_id(3), EVP_PKEY_CTX_free(3) and EVP_PKEY_CTX_dup(3) for the deets 🎀
int (*paramgen_init) (EVP_PKEY_CTX *ctx);
int (*paramgen) (EVP_PKEY_CTX *ctx, EVP_PKEY *pkey);paramgen_init() and paramgen() are your key parameter generation girlies. They get called by EVP_PKEY_paramgen_init(3) and EVP_PKEY_paramgen(3) to handle the whole parameter generation process 🌸
int (*keygen_init) (EVP_PKEY_CTX *ctx);
int (*keygen) (EVP_PKEY_CTX *ctx, EVP_PKEY *pkey);keygen_init() and keygen() are the ones that generate the actual key for the specified algorithm. Called by EVP_PKEY_keygen_init(3) and EVP_PKEY_keygen(3). 🔑
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);sign_init() and sign() generate the signature of a piece of data using a private key. Called by EVP_PKEY_sign_init(3) and EVP_PKEY_sign(3) ✍️
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);verify_init() and verify() check whether a signature is actually valid. Called by EVP_PKEY_verify_init(3) and EVP_PKEY_verify(3) 🕵️♀️
int (*verify_recover_init) (EVP_PKEY_CTX *ctx);
int (*verify_recover) (EVP_PKEY_CTX *ctx,
unsigned char *rout, size_t *routlen,
const unsigned char *sig, size_t siglen);verify_recover_init() and verify_recover() verify a signature and then recover the digest from that signature — think a signature generated by the RSA signing algorithm, that vibe. Called by EVP_PKEY_verify_recover_init(3) and EVP_PKEY_verify_recover(3) 🦋
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);signctx_init() and signctx() sign a digest that's present in an EVP_MD_CTX object. They get called by the EVP_DigestSign functions — see EVP_DigestSignInit(3) for the full story 📝
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);verifyctx_init() and verifyctx() verify a signature against the data sitting in an EVP_MD_CTX object. Called by the various EVP_DigestVerify functions — see EVP_DigestVerifyInit(3) for details 🔍
int (*encrypt_init) (EVP_PKEY_CTX *ctx);
int (*encrypt) (EVP_PKEY_CTX *ctx, unsigned char *out, size_t *outlen,
const unsigned char *in, size_t inlen);encrypt_init() and encrypt() encrypt a piece of data. Called by EVP_PKEY_encrypt_init(3) and EVP_PKEY_encrypt(3) 🔒
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);decrypt_init() and decrypt() decrypt a piece of data. Called by EVP_PKEY_decrypt_init(3) and EVP_PKEY_decrypt(3) 🔓
int (*derive_init) (EVP_PKEY_CTX *ctx);
int (*derive) (EVP_PKEY_CTX *ctx, unsigned char *key, size_t *keylen);derive_init() and derive() derive the shared secret from a public key algorithm — the DH algorithm is the classic example here. Called by EVP_PKEY_derive_init(3) and EVP_PKEY_derive(3) 🤝
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);ctrl() and ctrl_str() adjust algorithm-specific settings. See EVP_PKEY_CTX_ctrl(3) and related functions for the details ⚙️
int (*digestsign) (EVP_MD_CTX *ctx, unsigned char *sig, size_t *siglen,
const unsigned char *tbs, size_t tbslen);
int (*digestverify) (EVP_MD_CTX *ctx, const unsigned char *sig,
size_t siglen, const unsigned char *tbs,
size_t tbslen);digestsign() and digestverify() generate or verify a signature in one-shot mode. They could be called by EVP_DigestSign(3) and EVP_DigestVerify(3) ⚡
int (*check) (EVP_PKEY *pkey);
int (*public_check) (EVP_PKEY *pkey);
int (*param_check) (EVP_PKEY *pkey);check(), public_check() and param_check() validate a key-pair, the public component and parameters respectively, for a given pkey. They could be called by EVP_PKEY_check(3), EVP_PKEY_public_check(3) and EVP_PKEY_param_check(3) respectively ✅
int (*digest_custom) (EVP_PKEY_CTX *ctx, EVP_MD_CTX *mctx);digest_custom() generates customized digest content before the real message gets passed to functions like EVP_DigestSignUpdate(3) or EVP_DigestVerifyInit(3). Some public key signature algorithms need this — SM2 for example requires a hashed prefix to the message being signed. The digest_custom() function will be called by EVP_DigestSignInit(3) and EVP_DigestVerifyInit(3) 🎀
🌟 Functions 🌟
EVP_PKEY_meth_new() creates and returns a new EVP_PKEY_METHOD object, and associates the given id and flags. These are the supported flags:
EVP_PKEY_FLAG_AUTOARGLEN
EVP_PKEY_FLAG_SIGCTX_CUSTOMIf an EVP_PKEY_METHOD is set with the EVP_PKEY_FLAG_AUTOARGLEN flag, then the maximum size of the output buffer gets automatically calculated or checked in corresponding EVP methods by the EVP framework. Which means the implementations of these methods don't need to care about handling the case of returning output buffer size by themselves — the framework handles it, slay 💅 For details on the output buffer size, refer to EVP_PKEY_sign(3).
The EVP_PKEY_FLAG_SIGCTX_CUSTOM flag is used to indicate that the signctx() method of an EVP_PKEY_METHOD is always called by the EVP framework while doing a digest signing operation by calling EVP_DigestSignFinal(3).
EVP_PKEY_meth_free() frees an existing EVP_PKEY_METHOD pointed to by pmeth. If the argument is NULL, nothing is done. (respectful, we love a no-op 🫶)
EVP_PKEY_meth_copy() copies an EVP_PKEY_METHOD object from src to dst.
EVP_PKEY_meth_find() finds an EVP_PKEY_METHOD object with the given id. This function first searches through the user-defined method objects and then the built-in objects 🔎
EVP_PKEY_meth_add0() adds pmeth to the user defined stack of methods.
EVP_PKEY_meth_remove() removes an EVP_PKEY_METHOD object added by EVP_PKEY_meth_add0().
The EVP_PKEY_meth_set functions set the corresponding fields of the EVP_PKEY_METHOD structure with the arguments passed.
The EVP_PKEY_meth_get functions get the corresponding fields of the EVP_PKEY_METHOD structure into the arguments provided.
🎯 RETURN VALUES 🎯
EVP_PKEY_meth_new()returns a pointer to a newEVP_PKEY_METHODobject, or returnsNULLon error 😭EVP_PKEY_meth_free()andEVP_PKEY_meth_copy()do not return values.EVP_PKEY_meth_find()returns a pointer to the foundEVP_PKEY_METHODobject, or returnsNULLif not found.EVP_PKEY_meth_add0()returns1if method is added successfully, or0if an error occurred.EVP_PKEY_meth_remove()returns1if method is removed successfully, or0if an error occurred.- All
EVP_PKEY_meth_setandEVP_PKEY_meth_getfunctions have no return values. For the 'get' functions, function pointers are returned by arguments.
📜 HISTORY 📜
All of these functions were deprecated in OpenSSL 3.0. yep, we said it in the description and we're saying it again, consistency queen 👑
Also: the signature of the copy functional argument of EVP_PKEY_meth_set_copy() changed in OpenSSL 3.0, so its src parameter is now constified. character development, honestly ✨
©️ COPYRIGHT ©️
Copyright 2017-2024 The OpenSSL Project Authors. All Rights Reserved.
Licensed under the Apache License 2.0 (the "License"). You may not use this file except in compliance with the License. You can obtain a copy in the file LICENSE in the source distribution or at <https://www.openssl.org/source/license.html>.
and that's the whole page bestie, we made it to the end 🎉 the little footer down there says this is from OpenSSL 3.5.7, dated 2026-06-09, filed under EVP_PKEY_METH_NEW(3SSL) — go forth and deprecate responsibly 💜🦋
📦 where this page comes from
- debian trixie: libssl-doc 3.5.7-1~deb13u2 · Apache-2.0
- debian trixie: libssl-doc 3.5.7-1~deb13u3 · Apache-2.0
- 💖 girlified by deepseek-ai/DeepSeek-V4.1-Flash-1017 on : a language model's rewrite of the original, under its terms