PPCODE results from the CPAN

PPCODE

Crypt-OpenSSL3

view release on metacpan or search on metacpan

lib/Crypt/OpenSSL3.xs view on Meta::CPAN

	} else
		RETVAL = &PL_sv_undef;
OUTPUT: RETVAL

const char *X509_get_default_cert_file(class)
C_ARGS:

const char *X509_get_default_cert_dir(class)
C_ARGS:

const char *X509_get_default_cert_file_env(class)
C_ARGS:

const char *X509_get_default_cert_dir_env(class)
C_ARGS:

bool X509_sign(Crypt::OpenSSL3::X509 x, Crypt::OpenSSL3::PKey pkey, Crypt::OpenSSL3::MD md)

bool X509_sign_ctx(Crypt::OpenSSL3::X509 x, Crypt::OpenSSL3::MD::Context ctx)

bool X509_verify(Crypt::OpenSSL3::X509 x, Crypt::OpenSSL3::PKey pkey)

bool X509_self_signed(Crypt::OpenSSL3::X509 cert, bool verify_signature)

Crypt::OpenSSL3::PKey X509_get_pubkey(Crypt::OpenSSL3::X509 x)

bool X509_set_pubkey(Crypt::OpenSSL3::X509 x, Crypt::OpenSSL3::PKey pkey);

long X509_get_version(Crypt::OpenSSL3::X509 x)

bool X509_set_version(Crypt::OpenSSL3::X509 x, long version)

void X509_get_signature(Crypt::OpenSSL3::X509 x, OUTLIST const ASN1_BIT_STRING* psig, OUTLIST Crypt::OpenSSL3::X509::Algorithm palg)
C_ARGS: &psig, (const X509_ALGOR**)&palg, x
POSTCALL:
	palg = X509_ALGOR_dup(palg);

Crypt::OpenSSL3::NID X509_get_signature_nid(Crypt::OpenSSL3::X509 x)

Crypt::OpenSSL3::X509::Algorithm X509_get_tbs_sigalg(Crypt::OpenSSL3::X509 x)
POSTCALL:
	RETVAL = X509_ALGOR_dup(RETVAL);

ASN1_TIME* X509_get_notBefore(Crypt::OpenSSL3::X509 x)
INTERFACE: X509_get_notBefore X509_get_notAfter
POSTCALL:
	RETVAL = ASN1_TIME_dup(RETVAL);

bool X509_set_notBefore(Crypt::OpenSSL3::X509 x, ASN1_TIME* tm)
INTERFACE: X509_set_notBefore  X509_set_notAfter
POSTCALL:
	ASN1_TIME_free(tm);

Crypt::OpenSSL3::X509::Name X509_get_subject_name(Crypt::OpenSSL3::X509 x)
INTERFACE:
	X509_get_subject_name  X509_get_issuer_name
POSTCALL:
	RETVAL = X509_NAME_dup(RETVAL);

void X509_get_subject_alt_names(Crypt::OpenSSL3::X509 x)
PPCODE:
	STACK_OF(GENERAL_NAME)* gens = X509_get_ext_d2i(x, NID_subject_alt_name, NULL, NULL);
	STACK_TO_STACK(GENERAL_NAME, gens);

void X509_get_issuer_alt_names(Crypt::OpenSSL3::X509 x)
PPCODE:
	STACK_OF(GENERAL_NAME)* gens = X509_get_ext_d2i(x, NID_issuer_alt_name, NULL, NULL);
	STACK_TO_STACK(GENERAL_NAME, gens);

bool X509_set_subject_name(Crypt::OpenSSL3::X509 x, Crypt::OpenSSL3::X509::Name name)

bool X509_set_issuer_name(Crypt::OpenSSL3::X509 x, Crypt::OpenSSL3::X509::Name name)

unsigned long X509_subject_name_hash(Crypt::OpenSSL3::X509 x)

unsigned long X509_issuer_name_hash(Crypt::OpenSSL3::X509 x)

void X509_get_ct_precert_scts(Crypt::OpenSSL3::X509 x)
PPCODE:
	STACK_OF(SCT)* scts = X509_get_ext_d2i(x, NID_ct_precert_scts, NULL, NULL);
	STACK_TO_STACK(SCT, scts);

NO_OUTPUT Bool X509_digest(Crypt::OpenSSL3::X509 data, Crypt::OpenSSL3::MD type, OUTLIST SV* digest)
INTERFACE: X509_digest  X509_pubkey_digest
INIT:
	unsigned int output_length = EVP_MD_size(type);
	unsigned char* ptr = make_buffer(&digest, output_length);
C_ARGS: data, type, ptr, &output_length
POSTCALL:
	if (RETVAL)
		set_buffer_length(digest, output_length);

ASN1_OCTET_STRING* X509_digest_sig(Crypt::OpenSSL3::X509 cert)
C_ARGS: cert, NULL, NULL
CLEANUP:
	ASN1_OCTET_STRING_free(RETVAL);

ASN1_OCTET_STRING* X509_get_distinguishing_id(Crypt::OpenSSL3::X509 x)
POSTCALL:
	if (!RETVAL)
		XSRETURN_UNDEF;

void X509_set_distinguishing_id(Crypt::OpenSSL3::X509 x, ASN1_OCTET_STRING* distid)

bool X509_check_ca(Crypt::OpenSSL3::X509 cert)

bool X509_check_host(Crypt::OpenSSL3::X509 cert, const char *name, size_t length(name), unsigned int flags, OUTLIST char *peername)

bool X509_check_email(Crypt::OpenSSL3::X509 cert, const char *address, size_t length(address), unsigned int flags)

bool X509_check_ip(Crypt::OpenSSL3::X509 cert, const unsigned char *address, size_t length(address), unsigned int flags)

bool X509_check_ip_asc(Crypt::OpenSSL3::X509 cert, const char *address, unsigned int flags)

bool X509_check_issued(Crypt::OpenSSL3::X509 issuer, Crypt::OpenSSL3::X509 subject)

bool X509_check_private_key(Crypt::OpenSSL3::X509 cert, Crypt::OpenSSL3::PKey pkey)

int X509_cmp(Crypt::OpenSSL3::X509 a, Crypt::OpenSSL3::X509 b)

int X509_issuer_and_serial_cmp(Crypt::OpenSSL3::X509 a, Crypt::OpenSSL3::X509 b)

int X509_issuer_name_cmp(Crypt::OpenSSL3::X509 a, Crypt::OpenSSL3::X509 b)

int X509_subject_name_cmp(Crypt::OpenSSL3::X509 a, Crypt::OpenSSL3::X509 b)

long X509_get_pathlen(Crypt::OpenSSL3::X509 x)

uint32_t X509_get_extension_flags(Crypt::OpenSSL3::X509 x)

uint32_t X509_get_key_usage(Crypt::OpenSSL3::X509 x)

uint32_t X509_get_extended_key_usage(Crypt::OpenSSL3::X509 x)

const ASN1_OCTET_STRING* X509_get_subject_key_id(Crypt::OpenSSL3::X509 x)
INTERFACE: X509_get_subject_key_id X509_get_authority_key_id
POSTCALL:
	if (!RETVAL)
		XSRETURN_UNDEF;

Crypt::OpenSSL3::X509::GeneralName X509_get_authority_issuer(Crypt::OpenSSL3::X509 x)
PPCODE:
	const STACK_OF(GENERAL_NAME)* gns = X509_get0_authority_issuer(x);
	CSTACK_TO_STACK(GENERAL_NAME, gns);

const ASN1_INTEGER* X509_get_authority_serial(Crypt::OpenSSL3::X509 x)
POSTCALL:
	if (!RETVAL)
		XSRETURN_UNDEF;

void X509_set_proxy_flag(Crypt::OpenSSL3::X509 x)

void X509_set_proxy_pathlen(Crypt::OpenSSL3::X509 x, int l)

long X509_get_proxy_pathlen(Crypt::OpenSSL3::X509 x)

int X509_get_ext_count(Crypt::OpenSSL3::X509 x)

void X509_get_extensions(Crypt::OpenSSL3::X509 x)
PPCODE:
	const STACK_OF(X509_EXTENSION)* exts = X509_get0_extensions(x);
	CSTACK_TO_STACK(X509_EXTENSION, exts);

Crypt::OpenSSL3::X509::Extension X509_get_ext(Crypt::OpenSSL3::X509 x, int loc)
POSTCALL:
	if (RETVAL)
		RETVAL = X509_EXTENSION_dup(RETVAL);
	else
		XSRETURN_UNDEF;

int X509_get_ext_by_NID(Crypt::OpenSSL3::X509 x, Crypt::OpenSSL3::NID nid, int lastpos = -1)
POSTCALL:
	if (RETVAL == -1)
		XSRETURN_UNDEF;

int X509_get_ext_by_OBJ(Crypt::OpenSSL3::X509 x, Crypt::OpenSSL3::ASN1::Object obj, int lastpos = -1)
POSTCALL:
	if (RETVAL == -1)
		XSRETURN_UNDEF;

int X509_get_ext_by_critical(Crypt::OpenSSL3::X509 x, int crit, int lastpos = -1)
POSTCALL:
	if (RETVAL == -1)
		XSRETURN_UNDEF;

Crypt::OpenSSL3::X509::Extension X509_delete_ext(Crypt::OpenSSL3::X509 x, int loc)

int X509_add_ext(Crypt::OpenSSL3::X509 x, Crypt::OpenSSL3::X509::Extension ex, int loc = -1)

ASN1_INTEGER* X509_get_serialNumber(Crypt::OpenSSL3::X509 x)

bool X509_set_serialNumber(Crypt::OpenSSL3::X509 x, ASN1_INTEGER* serial)
POSTCALL:
	ASN1_INTEGER_free(serial);


MODULE = Crypt::OpenSSL3	PACKAGE = Crypt::OpenSSL3::X509::VerifyParam	PREFIX = X509_VERIFY_PARAM_

BOOT:
{
	HV* stash = gv_stashpvs("Crypt::OpenSSL3::X509::VerifyParam", GV_ADD | GV_ADDMULTI);

	CONSTANT2(X509_, PURPOSE_SSL_CLIENT);
	CONSTANT2(X509_, PURPOSE_SSL_SERVER);
	CONSTANT2(X509_, PURPOSE_NS_SSL_SERVER);
	CONSTANT2(X509_, PURPOSE_SMIME_SIGN);
	CONSTANT2(X509_, PURPOSE_SMIME_ENCRYPT);
	CONSTANT2(X509_, PURPOSE_CRL_SIGN);
	CONSTANT2(X509_, PURPOSE_ANY);
	CONSTANT2(X509_, PURPOSE_OCSP_HELPER);
	CONSTANT2(X509_, PURPOSE_TIMESTAMP_SIGN);
#if OPENSSL_VERSION_PREREQ(3, 1)
	CONSTANT2(X509_, PURPOSE_CODE_SIGN);
#endif

	CONSTANT2(X509_, V_FLAG_USE_CHECK_TIME);
	CONSTANT2(X509_, V_FLAG_CRL_CHECK);
	CONSTANT2(X509_, V_FLAG_CRL_CHECK_ALL);
	CONSTANT2(X509_, V_FLAG_IGNORE_CRITICAL);
	CONSTANT2(X509_, V_FLAG_X509_STRICT);

lib/Crypt/OpenSSL3.xs view on Meta::CPAN

		i2d_X509_NAME(x, &ptr);
		set_buffer_length(RETVAL, length);
	} else
		RETVAL = &PL_sv_undef;
OUTPUT: RETVAL


MODULE = Crypt::OpenSSL3	PACKAGE = Crypt::OpenSSL3::X509::Name::Entry	PREFIX = X509_NAME_ENTRY

Crypt::OpenSSL3::X509::Name::Entry X509_NAME_ENTRY_new(class)
C_ARGS:

Crypt::OpenSSL3::ASN1::Object X509_NAME_ENTRY_get_object(Crypt::OpenSSL3::X509::Name::Entry ne)
POSTCALL:
	if (RETVAL)
		RETVAL = ASN1_OBJECT_dup(RETVAL);
	else
		XSRETURN_UNDEF;

ASN1_OCTET_STRING* X509_NAME_ENTRY_get_data(Crypt::OpenSSL3::X509::Name::Entry ne)
POSTCALL:
	if (!RETVAL)
		XSRETURN_UNDEF;

bool X509_NAME_ENTRY_set_object(Crypt::OpenSSL3::X509::Name::Entry ne, Crypt::OpenSSL3::ASN1::Object obj)

bool X509_NAME_ENTRY_set_data(Crypt::OpenSSL3::X509::Name::Entry ne, int type, const unsigned char *bytes, int length(bytes))

MODULE = Crypt::OpenSSL3	PACKAGE = Crypt::OpenSSL3::X509::Store	PREFIX = X509_STORE_

Crypt::OpenSSL3::X509::Store X509_STORE_new(class)
C_ARGS:

bool X509_STORE_lock(Crypt::OpenSSL3::X509::Store store)

bool X509_STORE_unlock(Crypt::OpenSSL3::X509::Store store)

bool X509_STORE_add_cert(Crypt::OpenSSL3::X509::Store store, Crypt::OpenSSL3::X509 x)

bool X509_STORE_set_depth(Crypt::OpenSSL3::X509::Store store, int depth)

bool X509_STORE_set_flags(Crypt::OpenSSL3::X509::Store store, unsigned long flags)

bool X509_STORE_set_purpose(Crypt::OpenSSL3::X509::Store store, int purpose)

bool X509_STORE_set_trust(Crypt::OpenSSL3::X509::Store store, int trust)

bool X509_STORE_load_locations(Crypt::OpenSSL3::X509::Store store, const char *file, const char *dir)

bool X509_STORE_set_default_paths(Crypt::OpenSSL3::X509::Store store)

bool X509_STORE_load_file(Crypt::OpenSSL3::X509::Store xs, const char *file, const char *propq = NULL)
C_ARGS: xs, file, NULL, propq

bool X509_STORE_load_path(Crypt::OpenSSL3::X509::Store xs, const char *dir)

bool X509_STORE_load_store(Crypt::OpenSSL3::X509::Store xs, const char *uri, const char *propq = NULL)
C_ARGS: xs, uri, NULL, propq

void X509_STORE_get_all_certs(Crypt::OpenSSL3::X509::Store xs)
PPCODE:
	STACK_OF(X509)* stack = X509_STORE_get1_all_certs(xs);
	STACK_TO_STACK(X509, stack);


MODULE = Crypt::OpenSSL3	PACKAGE = Crypt::OpenSSL3::X509::Store::Context	PREFIX = X509_STORE_CTX_

Crypt::OpenSSL3::X509::Store::Context X509_STORE_CTX_new(const char *propq = NULL)
C_ARGS: NULL, propq

bool X509_STORE_CTX_init(Crypt::OpenSSL3::X509::Store::Context ctx, Crypt::OpenSSL3::X509::Store trust_store, Crypt::OpenSSL3::X509 target, STACK_OF(X509)* untrusted = NULL)
POSTCALL:
	sk_X509_free(untrusted);

#if OPENSSL_VERSION_PREREQ(3, 2)

bool X509_STORE_CTX_init_rpk(Crypt::OpenSSL3::X509::Store::Context ctx, Crypt::OpenSSL3::X509::Store trust_store, Crypt::OpenSSL3::PKey rpk)

void X509_STORE_CTX_set_rpk(Crypt::OpenSSL3::X509::Store::Context ctx, Crypt::OpenSSL3::PKey target)
INIT:
	EVP_PKEY_up_ref(target);

Crypt::OpenSSL3::PKey X509_STORE_CTX_get_rpk(Crypt::OpenSSL3::X509::Store::Context ctx)
POSTCALL:
	if (RETVAL)
		EVP_PKEY_up_ref(RETVAL);
	else
		XSRETURN_UNDEF;

#endif

void X509_STORE_CTX_set_trusted_stack(Crypt::OpenSSL3::X509::Store::Context ctx, STACK_OF(X509)* sk)

void X509_STORE_CTX_set_cert(Crypt::OpenSSL3::X509::Store::Context ctx, Crypt::OpenSSL3::X509 target)

Crypt::OpenSSL3::X509::VerifyParam X509_STORE_CTX_get_param(Crypt::OpenSSL3::X509::Store::Context ctx)

void X509_STORE_CTX_set_param(Crypt::OpenSSL3::X509::Store::Context ctx, Crypt::OpenSSL3::X509::VerifyParam param)

void X509_STORE_CTX_get_untrusted(Crypt::OpenSSL3::X509::Store::Context ctx)
PPCODE:
	STACK_OF(X509)* stack = X509_STORE_CTX_get0_untrusted(ctx);
	CSTACK_TO_STACK(X509, stack);

void X509_STORE_CTX_set_untrusted(Crypt::OpenSSL3::X509::Store::Context ctx, STACK_OF(X509)* sk)

int X509_STORE_CTX_get_num_untrusted(Crypt::OpenSSL3::X509::Store::Context ctx)

void X509_STORE_CTX_get_chain(Crypt::OpenSSL3::X509::Store::Context ctx)
PPCODE:
	STACK_OF(X509)* stack = X509_STORE_CTX_get0_chain(ctx);
	CSTACK_TO_STACK(X509, stack);

void X509_STORE_CTX_set_verified_chain(Crypt::OpenSSL3::X509::Store::Context ctx, STACK_OF(X509)* chain)

bool X509_STORE_CTX_set_default(Crypt::OpenSSL3::X509::Store::Context ctx, const char *name)

bool X509_STORE_CTX_set_purpose(Crypt::OpenSSL3::X509::Store::Context ctx, int purpose)

bool X509_STORE_CTX_set_trust(Crypt::OpenSSL3::X509::Store::Context ctx, int trust)

int X509_STORE_CTX_purpose_inherit(Crypt::OpenSSL3::X509::Store::Context ctx, int def_purpose, int purpose, int trust)

void X509_STORE_CTX_set_time(Crypt::OpenSSL3::X509::Store::Context ctx, time_t t, unsigned long flags = 0)
C_ARGS: ctx, flags, t

int X509_STORE_CTX_verify(Crypt::OpenSSL3::X509::Store::Context ctx)

int X509_STORE_CTX_get_error(Crypt::OpenSSL3::X509::Store::Context ctx)

const char *X509_STORE_CTX_get_error_string(Crypt::OpenSSL3::X509::Store::Context ctx)
CODE:
	int code = X509_STORE_CTX_get_error(ctx);
	RETVAL = X509_verify_cert_error_string(code);
OUTPUT: RETVAL

void X509_STORE_CTX_set_error(Crypt::OpenSSL3::X509::Store::Context ctx, int s)

int X509_STORE_CTX_get_error_depth(Crypt::OpenSSL3::X509::Store::Context ctx)

void X509_STORE_CTX_set_error_depth(Crypt::OpenSSL3::X509::Store::Context ctx, int depth)

Crypt::OpenSSL3::X509 X509_STORE_CTX_get_cert(Crypt::OpenSSL3::X509::Store::Context ctx)
POSTCALL:
	if (RETVAL)
		X509_up_ref(RETVAL);
	else
		XSRETURN_UNDEF;

MODULE = Crypt::OpenSSL3	PACKAGE = Crypt::OpenSSL3::X509::Request	PREFIX = X509_REQ_

Crypt::OpenSSL3::X509::Request X509_REQ_new(class, const char *propq = NULL)
C_ARGS: NULL, propq

Crypt::OpenSSL3::X509::Request X509_REQ_dup(Crypt::OpenSSL3::X509::Request req)

Crypt::OpenSSL3::X509::Request X509_REQ_read_pem(class, Crypt::OpenSSL3::BIO bio)
C_ARGS: bio, NULL, NULL, NULL
POSTCALL:
	if (!RETVAL)
		XSRETURN_UNDEF;

bool X509_REQ_write_pem(Crypt::OpenSSL3::X509::Request x, Crypt::OpenSSL3::BIO bio)
C_ARGS: bio, x

Crypt::OpenSSL3::X509::Request X509_REQ_read_der(class, Crypt::OpenSSL3::BIO bio)
C_ARGS: bio, NULL
POSTCALL:
	if (!RETVAL)
		XSRETURN_UNDEF;

lib/Crypt/OpenSSL3.xs view on Meta::CPAN

Crypt::OpenSSL3::X509::Request X509_REQ_decode_der(class, ASN1_DECODER* buffer)
CODE:
	RETVAL = d2i_X509_REQ(NULL, &buffer->ptr, buffer->end - buffer->ptr);
	if (!RETVAL)
		XSRETURN_UNDEF;
OUTPUT: RETVAL

SV* X509_REQ_encode_der(Crypt::OpenSSL3::X509::Request x)
CODE:
	int length = i2d_X509_REQ(x, NULL);
	if (length > 0) {
		unsigned char* ptr = make_buffer(&RETVAL, length);
		i2d_X509_REQ(x, &ptr);
		set_buffer_length(RETVAL, length);
	} else
		RETVAL = &PL_sv_undef;
OUTPUT: RETVAL

SV* X509_REQ_encode_der_tbs(Crypt::OpenSSL3::X509::Request x)
CODE:
	int length = i2d_re_X509_REQ_tbs(x, NULL);
	if (length > 0) {
		unsigned char* ptr = make_buffer(&RETVAL, length);
		i2d_re_X509_REQ_tbs(x, &ptr);
		set_buffer_length(RETVAL, length);
	} else
		RETVAL = &PL_sv_undef;
OUTPUT: RETVAL

int X509_REQ_get_attr_count(Crypt::OpenSSL3::X509::Request req)

int X509_REQ_get_attr_by_NID(Crypt::OpenSSL3::X509::Request req, Crypt::OpenSSL3::NID nid, int lastpos = -1)
POSTCALL:
	if (RETVAL == -1)
		XSRETURN_UNDEF;

int X509_REQ_get_attr_by_OBJ(Crypt::OpenSSL3::X509::Request req, Crypt::OpenSSL3::ASN1::Object obj, int lastpos = -1)
POSTCALL:
	if (RETVAL == -1)
		XSRETURN_UNDEF;

Crypt::OpenSSL3::X509::Attribute X509_REQ_get_attr(Crypt::OpenSSL3::X509::Request req, int loc)
POSTCALL:
	if (!RETVAL)
		XSRETURN_UNDEF;

Crypt::OpenSSL3::X509::Attribute X509_REQ_delete_attr(Crypt::OpenSSL3::X509::Request req, int loc)
POSTCALL:
	if (!RETVAL)
		XSRETURN_UNDEF;

bool X509_REQ_add_attr(Crypt::OpenSSL3::X509::Request req, Crypt::OpenSSL3::X509::Attribute attr)

bool X509_REQ_add_attr_by_OBJ(Crypt::OpenSSL3::X509::Request req, Crypt::OpenSSL3::ASN1::Object obj, int type, const unsigned char *bytes, int length(bytes))

bool X509_REQ_add_attr_by_NID(Crypt::OpenSSL3::X509::Request req, Crypt::OpenSSL3::NID nid, int type, const unsigned char *bytes, int len)

bool X509_REQ_add_attr_by_txt(Crypt::OpenSSL3::X509::Request req, const char *attrname, int type, const unsigned char *bytes, int len)

void X509_REQ_get_extensions(Crypt::OpenSSL3::X509::Request req)
PPCODE:
	STACK_OF(X509_EXTENSION)* exts = X509_REQ_get_extensions(req);
	CSTACK_TO_STACK(X509_EXTENSION, exts);

bool X509_REQ_add_extensions(Crypt::OpenSSL3::X509::Request req, STACK_OF(X509_EXTENSION) *exts)
POSTCALL:
	sk_X509_EXTENSION_free(exts);

bool X509_REQ_add_extensions_nid(Crypt::OpenSSL3::X509::Request req, STACK_OF(X509_EXTENSION) *exts, Crypt::OpenSSL3::NID nid)
POSTCALL:
	sk_X509_EXTENSION_free(exts);

bool X509_REQ_check_private_key(Crypt::OpenSSL3::X509::Request cert, Crypt::OpenSSL3::PKey pkey)

NO_OUTPUT Bool X509_REQ_digest(Crypt::OpenSSL3::X509::Request data, Crypt::OpenSSL3::MD type, OUTLIST SV* digest)
INIT:
	unsigned int output_length = EVP_MD_size(type);
	unsigned char* ptr = make_buffer(&digest, output_length);
C_ARGS: data, type, ptr, &output_length
POSTCALL:
	if (RETVAL)
		set_buffer_length(digest, output_length);

ASN1_OCTET_STRING* X509_REQ_get_distinguishing_id(Crypt::OpenSSL3::X509::Request x)

void X509_REQ_set_distinguishing_id(Crypt::OpenSSL3::X509::Request x, ASN1_OCTET_STRING* distid)

Crypt::OpenSSL3::PKey X509_REQ_get_pubkey(Crypt::OpenSSL3::X509::Request x)

bool X509_REQ_set_pubkey(Crypt::OpenSSL3::X509::Request x, Crypt::OpenSSL3::PKey pkey)


Crypt::OpenSSL3::X509::Name X509_REQ_get_subject_name(Crypt::OpenSSL3::X509::Request x)
POSTCALL:
	RETVAL = X509_NAME_dup(RETVAL);

bool X509_REQ_set_subject_name(Crypt::OpenSSL3::X509::Request x, Crypt::OpenSSL3::X509::Name name)

void X509_REQ_set_signature(Crypt::OpenSSL3::X509::Request req, ASN1_OCTET_STRING* psig)

void X509_REQ_get_signature(Crypt::OpenSSL3::X509::Request req, OUTLIST const ASN1_OCTET_STRING* psig, OUTLIST Crypt::OpenSSL3::X509::Algorithm palg)
C_ARGS: req, &psig, (const X509_ALGOR**)&palg
POSTCALL:
	palg = X509_ALGOR_dup(palg);
	
int X509_REQ_set_signature_algo(Crypt::OpenSSL3::X509::Request req, Crypt::OpenSSL3::X509::Algorithm palg)

Crypt::OpenSSL3::NID X509_REQ_get_signature_nid(Crypt::OpenSSL3::X509::Request req)

long X509_REQ_get_version(Crypt::OpenSSL3::X509::Request req)

int X509_REQ_set_version(Crypt::OpenSSL3::X509::Request x, long version)

int X509_REQ_verify(Crypt::OpenSSL3::X509::Request a, Crypt::OpenSSL3::PKey r, const char *propq = NULL)
C_ARGS: a, r, NULL, propq

int X509_REQ_sign(Crypt::OpenSSL3::X509::Request x, Crypt::OpenSSL3::PKey pkey, Crypt::OpenSSL3::MD md)

int X509_REQ_sign_ctx(Crypt::OpenSSL3::X509::Request x, Crypt::OpenSSL3::MD::Context ctx)

lib/Crypt/OpenSSL3.xs view on Meta::CPAN

	CONSTANT2(PKCS7_, STREAM);

	CONSTANT2(PKCS7_, NOINTERN);
	CONSTANT2(PKCS7_, NOCRL);
	CONSTANT2(PKCS7_, NOVERIFY);
	CONSTANT2(PKCS7_, NOCHAIN);
	CONSTANT2(PKCS7_, NOSIGS);
}

Crypt::OpenSSL3::PKCS7 PKCS7_new(class, const char* propq = NULL)
C_ARGS: NULL, propq

Crypt::OpenSSL3::PKCS7 PKCS7_read_pem(class, Crypt::OpenSSL3::BIO bio)
C_ARGS: bio, NULL, NULL, NULL
POSTCALL:
	if (!RETVAL)
		XSRETURN_UNDEF;

bool PKCS7_write_pem(Crypt::OpenSSL3::PKCS7 x, Crypt::OpenSSL3::BIO bio)
C_ARGS: bio, x

Crypt::OpenSSL3::PKCS7 PKCS7_read_der(class, Crypt::OpenSSL3::BIO bp)
C_ARGS: bp, NULL
POSTCALL:
	if (!RETVAL)
		XSRETURN_UNDEF;

int PKCS7_write_der(Crypt::OpenSSL3::PKCS7 p7, Crypt::OpenSSL3::BIO bio)
C_ARGS: bio, p7

Crypt::OpenSSL3::PKCS7 PKCS7_decode_der(class, ASN1_DECODER* buffer)
CODE:
	RETVAL = d2i_PKCS7(NULL, &buffer->ptr, buffer->end - buffer->ptr);
	if (!RETVAL)
		XSRETURN_UNDEF;
OUTPUT: RETVAL

SV* PKCS7_encode_der(Crypt::OpenSSL3::PKCS7 x)
CODE:
	int length = i2d_PKCS7(x, NULL);
	if (length > 0) {
		unsigned char* ptr = make_buffer(&RETVAL, length);
		i2d_PKCS7(x, &ptr);
		set_buffer_length(RETVAL, length);
	} else
		RETVAL = &PL_sv_undef;
OUTPUT: RETVAL

bool PKCS7_add_certificate(Crypt::OpenSSL3::PKCS7 p7, Crypt::OpenSSL3::X509 cert)

Crypt::OpenSSL3::PKCS7 PKCS7_sign(class, Crypt::OpenSSL3::X509 signcert, Crypt::OpenSSL3::PKey pkey, STACK_OF(X509)* certs, Crypt::OpenSSL3::BIO data, int flags, const char *propq = NULL)
C_ARGS: signcert, pkey, certs, data, flags, NULL, propq
POSTCALL:
	sk_X509_free(certs);

bool PKCS7_verify(Crypt::OpenSSL3::PKCS7 p7, STACK_OF(X509)* certs, Crypt::OpenSSL3::X509::Store store, Crypt::OpenSSL3::BIO indata, Crypt::OpenSSL3::BIO out, int flags)
POSTCALL:
	sk_X509_free(certs);

void PKCS7_get_signers(Crypt::OpenSSL3::PKCS7 p7, STACK_OF(X509)* certs, int flags = 0)
PPCODE:
	STACK_OF(X509)* stack = PKCS7_get0_signers(p7, certs, flags);
	CSTACK_TO_STACK(X509, stack);
	sk_X509_free(stack);

Crypt::OpenSSL3::PKCS7 PKCS7_encrypt(class, STACK_OF(X509)* certs, Crypt::OpenSSL3::BIO in, Crypt::OpenSSL3::Cipher cipher, int flags, const char* propq = NULL)
C_ARGS: certs, in, cipher, flags, NULL, propq
POSTCALL:
	sk_X509_free(certs);

bool PKCS7_decrypt(Crypt::OpenSSL3::PKCS7 p7, Crypt::OpenSSL3::PKey pkey, Crypt::OpenSSL3::X509 cert, Crypt::OpenSSL3::BIO data, int flags)

ASN1_OCTET_STRING* PKCS7_get_octet_string(Crypt::OpenSSL3::PKCS7 p7);

bool PKCS7_type_is_signed(Crypt::OpenSSL3::PKCS7 a)

bool PKCS7_type_is_encrypted(Crypt::OpenSSL3::PKCS7 a)

bool PKCS7_type_is_enveloped(Crypt::OpenSSL3::PKCS7 a)

bool PKCS7_type_is_signedAndEnveloped(Crypt::OpenSSL3::PKCS7 a)

bool PKCS7_type_is_data(Crypt::OpenSSL3::PKCS7 a)

bool PKCS7_type_is_digest(Crypt::OpenSSL3::PKCS7 a)

bool PKCS7_type_is_other(Crypt::OpenSSL3::PKCS7 p7)



MODULE = Crypt::OpenSSL3	PACKAGE = Crypt::OpenSSL3::SSL::Method	PREFIX = SSL_Method_

Crypt::OpenSSL3::SSL::Method SSL_Method_TLS()

Crypt::OpenSSL3::SSL::Method SSL_Method_TLS_server()

Crypt::OpenSSL3::SSL::Method SSL_Method_TLS_client()

Crypt::OpenSSL3::SSL::Method SSL_Method_DTLS()

Crypt::OpenSSL3::SSL::Method SSL_Method_DTLS_server()

Crypt::OpenSSL3::SSL::Method SSL_Method_DTLS_client()

#if OPENSSL_VERSION_PREREQ(3, 2)
Crypt::OpenSSL3::SSL::Method SSL_Method_QUIC_client()

Crypt::OpenSSL3::SSL::Method SSL_Method_QUIC_client_thread()
#endif

#if OPENSSL_VERSION_PREREQ(3, 5)
Crypt::OpenSSL3::SSL::Method SSL_Method_QUIC_server()
#endif

MODULE = Crypt::OpenSSL3	PACKAGE = Crypt::OpenSSL3::SSL::Context	PREFIX = SSL_CTX_

Crypt::OpenSSL3::SSL::Context SSL_CTX_new(classname, Crypt::OpenSSL3::SSL::Method method = TLS_method())
C_ARGS: method

long SSL_CTX_set_options(Crypt::OpenSSL3::SSL::Context ctx, long options)

lib/Crypt/OpenSSL3.xs view on Meta::CPAN

Crypt::OpenSSL3::SSL::Session SSL_SESSION_decode_der(class, ASN1_DECODER* buffer)
CODE:
	RETVAL = d2i_SSL_SESSION(NULL, &buffer->ptr, buffer->end - buffer->ptr);
	if (!RETVAL)
		XSRETURN_UNDEF;
OUTPUT: RETVAL

SV* SSL_SESSION_encode_der(Crypt::OpenSSL3::SSL::Session x)
CODE:
	int length = i2d_SSL_SESSION(x, NULL);
	if (length > 0) {
		unsigned char* ptr = make_buffer(&RETVAL, length);
		i2d_SSL_SESSION(x, &ptr);
		set_buffer_length(RETVAL, length);
	} else
		RETVAL = &PL_sv_undef;
OUTPUT: RETVAL


MODULE = Crypt::OpenSSL3	PACKAGE = Crypt::OpenSSL3::Timestamp::Request	PREFIX = TS_REQ_

Crypt::OpenSSL3::Timestamp::Request TS_REQ_new(class)
C_ARGS:

bool TS_REQ_set_version(Crypt::OpenSSL3::Timestamp::Request a, long version)

long TS_REQ_get_version(Crypt::OpenSSL3::Timestamp::Request a)

bool TS_REQ_set_msg_imprint(Crypt::OpenSSL3::Timestamp::Request a, Crypt::OpenSSL3::Timestamp::Imprint msg_imprint)
C_ARGS: a, TS_MSG_IMPRINT_dup(msg_imprint)

Crypt::OpenSSL3::Timestamp::Imprint TS_REQ_get_msg_imprint(Crypt::OpenSSL3::Timestamp::Request a)
POSTCALL:
	if (RETVAL)
		RETVAL = TS_MSG_IMPRINT_dup(RETVAL);
	else
		XSRETURN_UNDEF;

bool TS_REQ_set_policy_id(Crypt::OpenSSL3::Timestamp::Request a, Crypt::OpenSSL3::ASN1::Object policy)
C_ARGS: a, ASN1_OBJECT_dup(policy)

Crypt::OpenSSL3::ASN1::Object TS_REQ_get_policy_id(Crypt::OpenSSL3::Timestamp::Request a)
POSTCALL:
	if (RETVAL)
		RETVAL = ASN1_OBJECT_dup(RETVAL);
	else
		XSRETURN_UNDEF;

bool TS_REQ_set_nonce(Crypt::OpenSSL3::Timestamp::Request a, ASN1_INTEGER* nonce)

const ASN1_INTEGER* TS_REQ_get_nonce(Crypt::OpenSSL3::Timestamp::Request a)
POSTCALL:
	if (!RETVAL)
		XSRETURN_UNDEF;

bool TS_REQ_set_cert_req(Crypt::OpenSSL3::Timestamp::Request a, int cert_req)

int TS_REQ_get_cert_req(Crypt::OpenSSL3::Timestamp::Request a)

void TS_REQ_get_exts(Crypt::OpenSSL3::Timestamp::Request a)
PPCODE:
	STACK_OF(X509_EXTENSION)* exts = TS_REQ_get_exts(a);
	CSTACK_TO_STACK(X509_EXTENSION, exts);

int TS_REQ_get_ext_count(Crypt::OpenSSL3::Timestamp::Request a)

int TS_REQ_get_ext_by_NID(Crypt::OpenSSL3::Timestamp::Request a, Crypt::OpenSSL3::NID nid, int lastpos = -1)
POSTCALL:
	if (RETVAL == -1)
		XSRETURN_UNDEF;

int TS_REQ_get_ext_by_OBJ(Crypt::OpenSSL3::Timestamp::Request a, Crypt::OpenSSL3::ASN1::Object obj, int lastpos = -1)
POSTCALL:
	if (RETVAL == -1)
		XSRETURN_UNDEF;

int TS_REQ_get_ext_by_critical(Crypt::OpenSSL3::Timestamp::Request a, int crit, int lastpos = -1)
POSTCALL:
	if (RETVAL == -1)
		XSRETURN_UNDEF;

Crypt::OpenSSL3::X509::Extension TS_REQ_get_ext(Crypt::OpenSSL3::Timestamp::Request a, int loc)
POSTCALL:
	if (RETVAL)
		RETVAL = X509_EXTENSION_dup(RETVAL);
	else
		XSRETURN_UNDEF;

Crypt::OpenSSL3::X509::Extension TS_REQ_delete_ext(Crypt::OpenSSL3::Timestamp::Request a, int loc)
POSTCALL:
	if (!RETVAL)
		XSRETURN_UNDEF;

bool TS_REQ_add_ext(Crypt::OpenSSL3::Timestamp::Request a, Crypt::OpenSSL3::X509::Extension ex, int loc)
C_ARGS: a, X509_EXTENSION_dup(ex), loc

PrintRet TS_REQ_print(Crypt::OpenSSL3::Timestamp::Request a, Crypt::OpenSSL3::BIO bio)

Crypt::OpenSSL3::Timestamp::Request TS_REQ_read_der(class, Crypt::OpenSSL3::BIO bio)
C_ARGS: bio, NULL
POSTCALL:
	if (!RETVAL)
		XSRETURN_UNDEF;

bool TS_REQ_write_der(Crypt::OpenSSL3::Timestamp::Request x, Crypt::OpenSSL3::BIO bio)
C_ARGS: bio, x

Crypt::OpenSSL3::Timestamp::Request TS_REQ_decode_der(class, ASN1_DECODER* buffer)
CODE:
	RETVAL = d2i_TS_REQ(NULL, &buffer->ptr, buffer->end - buffer->ptr);
	if (!RETVAL)
		XSRETURN_UNDEF;
OUTPUT: RETVAL

SV* TS_REQ_encode_der(Crypt::OpenSSL3::Timestamp::Request x)
CODE:
	int length = i2d_TS_REQ(x, NULL);
	if (length > 0) {
		unsigned char* ptr = make_buffer(&RETVAL, length);
		i2d_TS_REQ(x, &ptr);
		set_buffer_length(RETVAL, length);

lib/Crypt/OpenSSL3.xs view on Meta::CPAN

C_ARGS:

bool TS_RESP_set_status_info(Crypt::OpenSSL3::Timestamp::Response a, Crypt::OpenSSL3::Timestamp::StatusInfo info)

Crypt::OpenSSL3::Timestamp::StatusInfo TS_RESP_get_status_info(Crypt::OpenSSL3::Timestamp::Response a)

Crypt::OpenSSL3::Timestamp::TokenInfo TS_RESP_get_tst_info(Crypt::OpenSSL3::Timestamp::Response a)
POSTCALL:
	if (RETVAL)
		RETVAL = TS_TST_INFO_dup(RETVAL);
	else
		XSRETURN_UNDEF;

Crypt::OpenSSL3::PKCS7 TS_RESP_get_token(Crypt::OpenSSL3::Timestamp::Response a)
POSTCALL:
	if (RETVAL)
		RETVAL = PKCS7_dup(RETVAL);
	else
		XSRETURN_UNDEF;

PrintRet TS_RESP_print(Crypt::OpenSSL3::Timestamp::Response a, Crypt::OpenSSL3::BIO bio)

Crypt::OpenSSL3::Timestamp::Response TS_RESP_read_der(class, Crypt::OpenSSL3::BIO bio)
C_ARGS: bio, NULL
POSTCALL:
	if (!RETVAL)
		XSRETURN_UNDEF;

bool TS_RESP_write_der(Crypt::OpenSSL3::Timestamp::Response x, Crypt::OpenSSL3::BIO bio)
C_ARGS: bio, x

Crypt::OpenSSL3::Timestamp::Response TS_RESP_decode_der(class, ASN1_DECODER* buffer)
CODE:
	RETVAL = d2i_TS_RESP(NULL, &buffer->ptr, buffer->end - buffer->ptr);
	if (!RETVAL)
		XSRETURN_UNDEF;
OUTPUT: RETVAL

SV* TS_RESP_encode_der(Crypt::OpenSSL3::Timestamp::Response x)
CODE:
	int length = i2d_TS_RESP(x, NULL);
	if (length > 0) {
		unsigned char* ptr = make_buffer(&RETVAL, length);
		i2d_TS_RESP(x, &ptr);
		set_buffer_length(RETVAL, length);
	} else
		RETVAL = &PL_sv_undef;
OUTPUT: RETVAL


MODULE = Crypt::OpenSSL3	PACKAGE = Crypt::OpenSSL3::Timestamp::StatusInfo	PREFIX = TS_STATUS_INFO_

Crypt::OpenSSL3::Timestamp::StatusInfo TS_STATUS_INFO_new(class)
C_ARGS:

bool TS_STATUS_INFO_set_status(Crypt::OpenSSL3::Timestamp::StatusInfo a, int i)

const ASN1_INTEGER* TS_STATUS_INFO_get_status(Crypt::OpenSSL3::Timestamp::StatusInfo a)

void TS_STATUS_INFO_get_text(Crypt::OpenSSL3::Timestamp::StatusInfo a)
PPCODE:
	const STACK_OF(ASN1_UTF8STRING)* stack = TS_STATUS_INFO_get0_text(a);
	if (stack) {
		int num = sk_ASN1_UTF8STRING_num(stack);
		EXTEND(SP, num);
		for (int i = 0; i < num; ++i) {
			ASN1_UTF8STRING* orig = sk_ASN1_UTF8STRING_value(stack, i);
			mPUSHs(ASN1_STRING_to_SV(V_ASN1_UTF8STRING, orig));
		}
	}

const ASN1_OCTET_STRING* TS_STATUS_INFO_get_failure_info(Crypt::OpenSSL3::Timestamp::StatusInfo a)


MODULE = Crypt::OpenSSL3	PACKAGE = Crypt::OpenSSL3::Timestamp::Accuracy	PREFIX = TS_ACCURACY_

Crypt::OpenSSL3::Timestamp::Accuracy TS_ACCURACY_new(class)
C_ARGS:

bool TS_ACCURACY_set_seconds(Crypt::OpenSSL3::Timestamp::Accuracy a, ASN1_INTEGER* seconds)
INTERFACE: TS_ACCURACY_set_seconds TS_ACCURACY_set_millis TS_ACCURACY_set_micros

ASN1_INTEGER* TS_ACCURACY_get_seconds(Crypt::OpenSSL3::Timestamp::Accuracy a)
INTERFACE: TS_ACCURACY_get_seconds TS_ACCURACY_get_millis TS_ACCURACY_get_micros
POSTCALL:
	if (!RETVAL)
		XSRETURN_UNDEF;

MODULE = Crypt::OpenSSL3	PACKAGE = Crypt::OpenSSL3::Timestamp::Responder	PREFIX = TS_RESP_CTX_


Crypt::OpenSSL3::Timestamp::Responder TS_RESP_CTX_new(class, const char *propq = NULL)
C_ARGS: NULL, propq

int TS_RESP_CTX_set_signer_cert(Crypt::OpenSSL3::Timestamp::Responder ctx, Crypt::OpenSSL3::X509 signer)

int TS_RESP_CTX_set_signer_key(Crypt::OpenSSL3::Timestamp::Responder ctx, Crypt::OpenSSL3::PKey key)

int TS_RESP_CTX_set_signer_digest(Crypt::OpenSSL3::Timestamp::Responder ctx, Crypt::OpenSSL3::MD signer_digest)

int TS_RESP_CTX_set_ess_cert_id_digest(Crypt::OpenSSL3::Timestamp::Responder ctx, Crypt::OpenSSL3::MD md)

int TS_RESP_CTX_set_def_policy(Crypt::OpenSSL3::Timestamp::Responder ctx, Crypt::OpenSSL3::ASN1::Object def_policy)

int TS_RESP_CTX_set_certs(Crypt::OpenSSL3::Timestamp::Responder ctx, STACK_OF(X509) *certs)
POSTCALL:
	sk_X509_free(certs);

int TS_RESP_CTX_add_policy(Crypt::OpenSSL3::Timestamp::Responder ctx, Crypt::OpenSSL3::ASN1::Object policy)

int TS_RESP_CTX_add_md(Crypt::OpenSSL3::Timestamp::Responder ctx, Crypt::OpenSSL3::MD md)

int TS_RESP_CTX_set_accuracy(Crypt::OpenSSL3::Timestamp::Responder ctx, int secs, int millis, int micros)

int TS_RESP_CTX_set_clock_precision_digits(Crypt::OpenSSL3::Timestamp::Responder ctx, unsigned clock_precision_digits)

void TS_RESP_CTX_add_flags(Crypt::OpenSSL3::Timestamp::Responder ctx, int flags)

void TS_RESP_CTX_set_serial_cb(Crypt::OpenSSL3::Timestamp::Responder ctx, SV *data)
C_ARGS: ctx, TS_RESP_CTX_serial_callback, data

lib/Crypt/OpenSSL3.xs view on Meta::CPAN


bool TS_VERIFY_CTX_set_store(Crypt::OpenSSL3::Timestamp::Verifier ctx, Crypt::OpenSSL3::X509::Store s)
POSTCALL:
	if (RETVAL)
		X509_STORE_up_ref(s);

bool TS_VERIFY_CTX_set_certs(Crypt::OpenSSL3::Timestamp::Verifier ctx, STACK_OF(X509)* certs)

int TS_VERIFY_CTX_verify_response(Crypt::OpenSSL3::Timestamp::Verifier ctx, Crypt::OpenSSL3::Timestamp::Response response)

int TS_VERIFY_CTX_verify_token(Crypt::OpenSSL3::Timestamp::Verifier ctx, Crypt::OpenSSL3::PKCS7 token)

Bool CLONE_SKIP(...)


MODULE = Crypt::OpenSSL3	PACKAGE = Crypt::OpenSSL3::NID PREFIX = NID_

Crypt::OpenSSL3::NID NID_create(class, const char *oid, const char *sn, const char *ln)
C_ARGS: oid, sn, ln
POSTCALL:
	if (RETVAL == NID_undef)
		XSRETURN_UNDEF;

Crypt::OpenSSL3::NID NID_from_long_name(class, const char* name)
C_ARGS: name

Crypt::OpenSSL3::NID NID_from_short_name(class, const char* name)
C_ARGS: name

Crypt::OpenSSL3::NID NID_from_text(class, const char* name)
C_ARGS: name

const char *NID_get_long_name(Crypt::OpenSSL3::NID n)

const char *NID_get_short_name(Crypt::OpenSSL3::NID n)

Crypt::OpenSSL3::ASN1::Object NID_to_object(Crypt::OpenSSL3::NID n)

bool NID_eq(Crypt::OpenSSL3::NID left, Crypt::OpenSSL3::NID right)

int NID_raw(Crypt::OpenSSL3::NID n)

bool NID_is_undef(Crypt::OpenSSL3::NID n)


MODULE = Crypt::OpenSSL3	PACKAGE = Crypt::OpenSSL3::Random	PREFIX = EVP_RAND_

Crypt::OpenSSL3::Random EVP_RAND_fetch(classname, const char* algorithm, const char* properties = "")
C_ARGS: NULL, algorithm, properties
POSTCALL:
	if (RETVAL == NULL)
		XSRETURN_UNDEF;

bool EVP_RAND_is_a(Crypt::OpenSSL3::Random rand, const char *name)

const char *EVP_RAND_get_name(Crypt::OpenSSL3::Random rand)

const char *EVP_RAND_get_description(Crypt::OpenSSL3::Random rand)

void EVP_RAND_names_list_all(Crypt::OpenSSL3::Random rand)
PPCODE:
	PUTBACK;
	EVP_RAND_names_do_all(rand, EVP_name_callback, iTHX);
	SPAGAIN;

void EVP_RAND_list_all_provided(classname)
PPCODE:
	PUTBACK;
	EVP_RAND_do_all_provided(NULL, EVP_RAND_provided_callback, iTHX);
	SPAGAIN;

SV* EVP_RAND_get_param(Crypt::OpenSSL3::Random rand, const char* name)
CODE:
	GENERATE_GET_PARAM(EVP_RAND, rand, name)
OUTPUT: RETVAL

MODULE = Crypt::OpenSSL3	PACKAGE = Crypt::OpenSSL3::Random	PREFIX = RAND_

NO_OUTPUT int RAND_bytes(classname, OUTLIST SV* buffer, int num)
INTERFACE: RAND_bytes  RAND_priv_bytes
INIT:
	unsigned char* ptr = make_buffer(&buffer, num);
C_ARGS: ptr, num
POSTCALL:
	if (RETVAL > 0)
		set_buffer_length(buffer, num);

Crypt::OpenSSL3::Random::Context RAND_get_primary(classname)
INTERFACE: RAND_get_primary  RAND_get_public  RAND_get_private
C_ARGS: NULL
POSTCALL:
	EVP_RAND_CTX_up_ref(RETVAL);

#if OPENSSL_VERSION_PREREQ(3, 2)
Bool RAND_set_public(classname, Crypt::OpenSSL3::Random::Context rand)
INTERFACE: RAND_set_public  RAND_set_private
C_ARGS: NULL, rand
POSTCALL:
	if (RETVAL)
		EVP_RAND_CTX_up_ref(rand);
#endif

MODULE = Crypt::OpenSSL3	PACKAGE = Crypt::OpenSSL3::Random::Context	PREFIX = EVP_RAND_CTX_

Crypt::OpenSSL3::Random::Context EVP_RAND_CTX_new(classname, Crypt::OpenSSL3::Random type, Crypt::OpenSSL3::Random::Context parent = NULL)
C_ARGS: type, parent

Crypt::OpenSSL3::Random EVP_RAND_CTX_get_rand(Crypt::OpenSSL3::Random::Context ctx)
POSTCALL:
	EVP_RAND_up_ref(RETVAL);

MODULE = Crypt::OpenSSL3	PACKAGE = Crypt::OpenSSL3::Random::Context	PREFIX = EVP_RAND_

bool EVP_RAND_instantiate(Crypt::OpenSSL3::Random::Context ctx, unsigned int strength, int prediction_resistance, const unsigned char *pstr, size_t length(pstr), PARAMS(EVP_RAND_CTX) params = NULL)

bool EVP_RAND_uninstantiate(Crypt::OpenSSL3::Random::Context ctx)

NO_OUTPUT int EVP_RAND_generate(Crypt::OpenSSL3::Random::Context ctx, OUTLIST SV* buffer, size_t outlen, unsigned int strength, int prediction_resistance, const unsigned char *addin, size_t length(addin))
INIT:
	unsigned char* ptr = make_buffer(&buffer, outlen);
C_ARGS: ctx, ptr, outlen, strength, prediction_resistance, addin, XSauto_length_of_addin
POSTCALL:
	if (RETVAL)
		set_buffer_length(buffer, outlen);

int EVP_RAND_reseed(Crypt::OpenSSL3::Random::Context ctx, int prediction_resistance, const unsigned char *ent, size_t length(ent), const unsigned char *addin, size_t addin_len)

NO_OUTPUT int EVP_RAND_nonce(Crypt::OpenSSL3::Random::Context ctx, OUTLIST SV* buffer, size_t outlen)
INIT:
	unsigned char* ptr = make_buffer(&buffer, outlen);
C_ARGS: ctx, ptr, outlen
POSTCALL:
	set_buffer_length(buffer, RETVAL);

bool EVP_RAND_enable_locking(Crypt::OpenSSL3::Random::Context ctx)

bool EVP_RAND_verify_zeroization(Crypt::OpenSSL3::Random::Context ctx)

unsigned int EVP_RAND_get_strength(Crypt::OpenSSL3::Random::Context ctx)

int EVP_RAND_get_state(Crypt::OpenSSL3::Random::Context ctx)


MODULE = Crypt::OpenSSL3	PACKAGE = Crypt::OpenSSL3::Cipher	PREFIX = EVP_CIPHER_

Crypt::OpenSSL3::Cipher EVP_CIPHER_fetch(classname, const char* algorithm, const char* properties = "")
C_ARGS: NULL, algorithm, properties
POSTCALL:
	if (RETVAL == NULL)
		XSRETURN_UNDEF;

Crypt::OpenSSL3::NID EVP_CIPHER_get_nid(Crypt::OpenSSL3::Cipher e)

int EVP_CIPHER_get_block_size(Crypt::OpenSSL3::Cipher e)

int EVP_CIPHER_get_key_length(Crypt::OpenSSL3::Cipher e)

int EVP_CIPHER_get_iv_length(Crypt::OpenSSL3::Cipher e)

unsigned long EVP_CIPHER_get_mode(Crypt::OpenSSL3::Cipher e)

int EVP_CIPHER_get_type(Crypt::OpenSSL3::Cipher cipher)

bool EVP_CIPHER_is_a(Crypt::OpenSSL3::Cipher cipher, const char *name)

const char *EVP_CIPHER_get_name(Crypt::OpenSSL3::Cipher cipher)

const char *EVP_CIPHER_get_description(Crypt::OpenSSL3::Cipher cipher)

void EVP_CIPHER_names_list_all(Crypt::OpenSSL3::Cipher cipher)
PPCODE:
	PUTBACK;
	EVP_CIPHER_names_do_all(cipher, EVP_name_callback, iTHX);
	SPAGAIN;

void EVP_CIPHER_list_all_provided(classname)
PPCODE:
	PUTBACK;
	EVP_CIPHER_do_all_provided(NULL, EVP_CIPHER_provided_callback, iTHX);
	SPAGAIN;

SV* EVP_CIPHER_get_param(Crypt::OpenSSL3::Cipher cipher, const char* name)
CODE:
	GENERATE_GET_PARAM(EVP_CIPHER, cipher, name)
OUTPUT: RETVAL


MODULE = Crypt::OpenSSL3	PACKAGE = Crypt::OpenSSL3::Cipher::Context	PREFIX = EVP_CIPHER_CTX_

Crypt::OpenSSL3::Cipher::Context EVP_CIPHER_CTX_new(classname)
C_ARGS:

Crypt::OpenSSL3::Cipher::Context EVP_CIPHER_CTX_dup(Crypt::OpenSSL3::Cipher::Context ctx)

bool EVP_CIPHER_CTX_copy(Crypt::OpenSSL3::Cipher::Context self, Crypt::OpenSSL3::Cipher::Context other)

bool EVP_CIPHER_CTX_reset(Crypt::OpenSSL3::Cipher::Context ctx)

bool EVP_CIPHER_CTX_init(Crypt::OpenSSL3::Cipher::Context ctx, Crypt::OpenSSL3::Cipher type, const unsigned char* key, int length(key), const unsigned char* iv, int length(iv), bool enc, CTX_PARAMS(EVP_CIPHER) params = NULL)
INIT:
	if (XSauto_length_of_key != EVP_CIPHER_get_key_length(type) || XSauto_length_of_iv != EVP_CIPHER_get_iv_length(type))
		XSRETURN_NO;
C_ARGS: ctx, type, key, iv, enc, params

NO_OUTPUT int EVP_CIPHER_CTX_update(Crypt::OpenSSL3::Cipher::Context ctx, const unsigned char* input, size_t length(input), OUTLIST SV* output)
INIT:
	int outl = XSauto_length_of_input + EVP_CIPHER_CTX_get_block_size(ctx);
	unsigned char* ptr = make_buffer(&output, outl);
C_ARGS: ctx, ptr, &outl, input, XSauto_length_of_input
POSTCALL:
	if (RETVAL)
		set_buffer_length(output, outl);

NO_OUTPUT int EVP_CIPHER_CTX_final(Crypt::OpenSSL3::Cipher::Context ctx, OUTLIST SV* output)
INIT:
	int size = EVP_CIPHER_CTX_get_block_size(ctx);
	unsigned char* ptr = make_buffer(&output, size);
C_ARGS: ctx, ptr, &size
POSTCALL:
	if (RETVAL)
		set_buffer_length(output, size);

bool EVP_CIPHER_CTX_set_params(Crypt::OpenSSL3::Cipher::Context ctx, PARAMS(EVP_CIPHER_CTX) params = NULL)

SV* EVP_CIPHER_CTX_get_param(Crypt::OpenSSL3::Cipher::Context ctx, const char* name)
CODE:
	GENERATE_GET_PARAM(EVP_CIPHER_CTX, ctx, name)
OUTPUT: RETVAL


Crypt::OpenSSL3::NID EVP_CIPHER_CTX_get_nid(Crypt::OpenSSL3::Cipher::Context e)

int EVP_CIPHER_CTX_get_block_size(Crypt::OpenSSL3::Cipher::Context e)

int EVP_CIPHER_CTX_get_key_length(Crypt::OpenSSL3::Cipher::Context e)

int EVP_CIPHER_CTX_get_iv_length(Crypt::OpenSSL3::Cipher::Context e)

lib/Crypt/OpenSSL3.xs view on Meta::CPAN

int EVP_CIPHER_CTX_type(Crypt::OpenSSL3::Cipher::Context ctx)

bool EVP_CIPHER_CTX_set_padding(Crypt::OpenSSL3::Cipher::Context ctx, int padding)

bool EVP_CIPHER_CTX_set_key_length(Crypt::OpenSSL3::Cipher::Context ctx, int keylen)

int EVP_CIPHER_CTX_ctrl(Crypt::OpenSSL3::Cipher::Context ctx, int cmd, int p1, char *p2)

NO_OUTPUT int EVP_CIPHER_CTX_rand_key(Crypt::OpenSSL3::Cipher::Context ctx, OUTLIST SV* key)
INIT:
	size_t size = EVP_CIPHER_CTX_key_length(ctx);
	unsigned char* ptr = make_buffer(&key, size);
C_ARGS: ctx, ptr
POSTCALL:
	if (RETVAL > 0)
		set_buffer_length(key, size);

Crypt::OpenSSL3::Cipher EVP_CIPHER_CTX_get_cipher(Crypt::OpenSSL3::Cipher::Context ctx)

const char *EVP_CIPHER_CTX_get_name(Crypt::OpenSSL3::Cipher::Context ctx)

bool EVP_CIPHER_CTX_is_encrypting(Crypt::OpenSSL3::Cipher::Context ctx)

bool EVP_CIPHER_CTX_set_aead_ivlen(Crypt::OpenSSL3::Cipher::Context ctx, int length)

NO_OUTPUT bool EVP_CIPHER_CTX_get_aead_tag(Crypt::OpenSSL3::Cipher::Context ctx, OUTLIST SV* tag)
INIT:
	int length = EVP_CIPHER_CTX_get_tag_length(ctx);
	unsigned char* ptr = make_buffer(&tag, length);
C_ARGS: ctx, ptr, length
POSTCALL:
	if (RETVAL)
		set_buffer_length(tag, length);

bool EVP_CIPHER_CTX_set_aead_tag(Crypt::OpenSSL3::Cipher::Context ctx, char* ptr, int length(ptr))

#if OPENSSL_VERSION_PREREQ(3, 4)
NO_OUTPUT int EVP_CIPHER_CTX_get_algor(Crypt::OpenSSL3::Cipher::Context ctx, OUTLIST Crypt::OpenSSL3::X509::Algorithm alg)
INIT:
	alg = NULL;
POSTCALL:
	if (!RETVAL)
		XSRETURN_UNDEF;
#endif

MODULE = Crypt::OpenSSL3	PACKAGE = Crypt::OpenSSL3::MD	PREFIX = EVP_MD_

Crypt::OpenSSL3::MD EVP_MD_fetch(classname, const char* algorithm, const char* properties = "")
C_ARGS: NULL, algorithm, properties
POSTCALL:
	if (RETVAL == NULL)
		XSRETURN_UNDEF;

const char *EVP_MD_get_name(Crypt::OpenSSL3::MD md)

const char *EVP_MD_get_description(Crypt::OpenSSL3::MD md)

bool EVP_MD_is_a(Crypt::OpenSSL3::MD md, const char *name)

void EVP_MD_names_list_all(Crypt::OpenSSL3::MD md)
PPCODE:
	PUTBACK;
	EVP_MD_names_do_all(md, EVP_name_callback, iTHX);
	SPAGAIN;

void EVP_MD_list_all_provided(classname)
PPCODE:
	PUTBACK;
	EVP_MD_do_all_provided(NULL, EVP_MD_provided_callback, iTHX);
	SPAGAIN;

Crypt::OpenSSL3::NID EVP_MD_get_type(Crypt::OpenSSL3::MD md)

Crypt::OpenSSL3::NID EVP_MD_get_pkey_type(Crypt::OpenSSL3::MD md)

int EVP_MD_get_size(Crypt::OpenSSL3::MD md)

int EVP_MD_get_block_size(Crypt::OpenSSL3::MD md)

unsigned long EVP_MD_get_flags(Crypt::OpenSSL3::MD md)

#if OPENSSL_VERSION_PREREQ(3, 4)
bool EVP_MD_xof(Crypt::OpenSSL3::MD md)
#endif

SV* EVP_MD_get_param(Crypt::OpenSSL3::MD md, const char* name)
CODE:
	GENERATE_GET_PARAM(EVP_MD, md, name)
OUTPUT: RETVAL

NO_OUTPUT bool EVP_MD_digest(Crypt::OpenSSL3::MD md, const char* input, size_t length(input), OUTLIST SV* digest)
INIT:
	unsigned int size = EVP_MD_get_size(md);
	unsigned char* ptr = make_buffer(&digest, size);
C_ARGS: input, XSauto_length_of_input, ptr, &size, md, NULL
POSTCALL:
	if (RETVAL)
		set_buffer_length(digest, size);


MODULE = Crypt::OpenSSL3	PACKAGE = Crypt::OpenSSL3::MD::Context	PREFIX = EVP_MD_CTX_

Crypt::OpenSSL3::MD::Context EVP_MD_CTX_new(classname)
C_ARGS:

Crypt::OpenSSL3::MD::Context EVP_MD_CTX_dup(Crypt::OpenSSL3::MD::Context ctx)

bool EVP_MD_CTX_copy(Crypt::OpenSSL3::MD::Context self, Crypt::OpenSSL3::MD::Context other)

bool EVP_MD_CTX_reset(Crypt::OpenSSL3::MD::Context ctx)

bool EVP_MD_CTX_init(Crypt::OpenSSL3::MD::Context ctx, Crypt::OpenSSL3::MD type, CTX_PARAMS(EVP_MD) params = NULL)

bool EVP_MD_CTX_update(Crypt::OpenSSL3::MD::Context ctx, const char *d, size_t length(d))

NO_OUTPUT bool EVP_MD_CTX_final(Crypt::OpenSSL3::MD::Context ctx, OUTLIST SV* digest)
INIT:
	unsigned int size = EVP_MD_CTX_size(ctx);
	unsigned char* ptr = make_buffer(&digest , size);
C_ARGS: ctx, ptr, &size
POSTCALL:
	if (RETVAL)
		set_buffer_length(digest, size);

NO_OUTPUT bool EVP_MD_CTX_final_xof(Crypt::OpenSSL3::MD::Context ctx, OUTLIST SV* digest, size_t outlen)
INIT:
	unsigned char* ptr = make_buffer(&digest, outlen);

lib/Crypt/OpenSSL3.xs view on Meta::CPAN

	if (EVP_DigestSign(ctx, NULL, &size, tbs, XSauto_length_of_tbs) == 1) {
		unsigned char* ptr = make_buffer(&RETVAL, size);
		if (EVP_DigestSign(ctx, ptr, &size, tbs, XSauto_length_of_tbs) == 1)
			set_buffer_length(RETVAL, size);
	} else
		RETVAL = &PL_sv_undef;
OUTPUT: RETVAL

bool EVP_MD_CTX_verify_init(Crypt::OpenSSL3::MD::Context ctx, Crypt::OpenSSL3::MD type, Crypt::OpenSSL3::PKey pkey, Crypt::OpenSSL3::PKey::Context pctx = NULL)
C_ARGS: ctx, pctx ? &pctx : NULL, type, NULL, pkey
	
bool EVP_MD_CTX_verify_update(Crypt::OpenSSL3::MD::Context ctx, const char *d, size_t length(d))

Success EVP_MD_CTX_verify_final(Crypt::OpenSSL3::MD::Context ctx, const unsigned char *sig, size_t length(sig))

Success EVP_MD_CTX_verify(Crypt::OpenSSL3::MD::Context ctx, const unsigned char *sig, size_t length(sig), const unsigned char *tbs, size_t length(tbs))

bool EVP_MD_CTX_set_params(Crypt::OpenSSL3::MD::Context ctx, PARAMS(EVP_MD_CTX) params = NULL)

SV* EVP_MD_CTX_get_param(Crypt::OpenSSL3::MD::Context ctx, const char* name)
CODE:
	GENERATE_GET_PARAM(EVP_MD_CTX, ctx, name)
OUTPUT: RETVAL


void EVP_MD_CTX_ctrl(Crypt::OpenSSL3::MD::Context ctx, int cmd, int p1, char* p2);

void EVP_MD_CTX_set_flags(Crypt::OpenSSL3::MD::Context ctx, int flags)

void EVP_MD_CTX_clear_flags(Crypt::OpenSSL3::MD::Context ctx, int flags)

int EVP_MD_CTX_test_flags(Crypt::OpenSSL3::MD::Context ctx, int flags)

Crypt::OpenSSL3::MD EVP_MD_CTX_get_md(Crypt::OpenSSL3::MD::Context ctx)

const char *EVP_MD_CTX_get_name(Crypt::OpenSSL3::MD::Context ctx)

int EVP_MD_CTX_get_size(Crypt::OpenSSL3::MD::Context ctx)

int EVP_MD_CTX_get_block_size(Crypt::OpenSSL3::MD::Context ctx)

int EVP_MD_CTX_get_type(Crypt::OpenSSL3::MD::Context ctx)



MODULE = Crypt::OpenSSL3	PACKAGE = Crypt::OpenSSL3::MAC	PREFIX = EVP_MAC_

Crypt::OpenSSL3::MAC EVP_MAC_fetch(classname, const char* algorithm, const char* properties = "")
C_ARGS: NULL, algorithm, properties
POSTCALL:
	if (RETVAL == NULL)
		XSRETURN_UNDEF;

const char *EVP_MAC_get_name(Crypt::OpenSSL3::MAC mac)

const char *EVP_MAC_get_description(Crypt::OpenSSL3::MAC mac)

bool EVP_MAC_is_a(Crypt::OpenSSL3::MAC mac, const char *name)

void EVP_MAC_names_list_all(Crypt::OpenSSL3::MAC mac)
PPCODE:
	PUTBACK;
	EVP_MAC_names_do_all(mac, EVP_name_callback, iTHX);
	SPAGAIN;

void EVP_MAC_list_all_provided(classname)
PPCODE:
	PUTBACK;
	EVP_MAC_do_all_provided(NULL, EVP_MAC_provided_callback, iTHX);
	SPAGAIN;

SV* EVP_MAC_get_param(Crypt::OpenSSL3::MAC mac, const char* name)
CODE:
	GENERATE_GET_PARAM(EVP_MAC, mac, name)
OUTPUT: RETVAL



MODULE = Crypt::OpenSSL3	PACKAGE = Crypt::OpenSSL3::MAC::Context	PREFIX = EVP_MAC_CTX_

Crypt::OpenSSL3::MAC::Context EVP_MAC_CTX_new(classname, Crypt::OpenSSL3::MAC ctx)
C_ARGS: ctx

Crypt::OpenSSL3::MAC::Context EVP_MAC_CTX_dup(Crypt::OpenSSL3::MAC::Context ctx)

Crypt::OpenSSL3::MAC EVP_MAC_CTX_get_mac(Crypt::OpenSSL3::MAC::Context ctx);
POSTCALL:
	EVP_MAC_up_ref(RETVAL);

size_t EVP_MAC_CTX_get_mac_size(Crypt::OpenSSL3::MAC::Context ctx)

size_t EVP_MAC_CTX_get_block_size(Crypt::OpenSSL3::MAC::Context ctx)

bool EVP_MAC_CTX_set_params(Crypt::OpenSSL3::MAC::Context ctx, PARAMS(EVP_MAC_CTX) params = NULL)

SV* EVP_MAC_CTX_get_param(Crypt::OpenSSL3::MAC::Context ctx, const char* name)
CODE:
	GENERATE_GET_PARAM(EVP_MAC_CTX, ctx, name)
OUTPUT: RETVAL



MODULE = Crypt::OpenSSL3	PACKAGE = Crypt::OpenSSL3::MAC::Context	PREFIX = EVP_MAC_

bool EVP_MAC_init(Crypt::OpenSSL3::MAC::Context ctx, const unsigned char *key, size_t length(key), PARAMS(EVP_MAC_CTX) params = NULL)

bool EVP_MAC_update(Crypt::OpenSSL3::MAC::Context ctx, const unsigned char *data, size_t length(data))

SV* EVP_MAC_final(Crypt::OpenSSL3::MAC::Context ctx)
CODE:
	size_t outsize = 0;
	if (EVP_MAC_final(ctx, NULL, &outsize, 0)) {
		unsigned char* ptr = make_buffer(&RETVAL, outsize);
		int result = EVP_MAC_final(ctx, ptr, &outsize, outsize);
		if (result)
			set_buffer_length(RETVAL, outsize);
	} else
		RETVAL = &PL_sv_undef;
OUTPUT: RETVAL

NO_OUTPUT int EVP_MAC_finalXOF(Crypt::OpenSSL3::MAC::Context ctx, OUTLIST SV* code, size_t outsize)
INIT:
	unsigned char* ptr = make_buffer(&code, outsize);
C_ARGS: ctx, ptr, outsize
POSTCALL:
	if (RETVAL)
		set_buffer_length(code, outsize);



MODULE = Crypt::OpenSSL3	PACKAGE = Crypt::OpenSSL3::KDF	PREFIX = EVP_KDF_

Crypt::OpenSSL3::KDF EVP_KDF_fetch(classname, const char* algorithm, const char* properties = "")
C_ARGS: NULL, algorithm, properties
POSTCALL:
	if (RETVAL == NULL)
		XSRETURN_UNDEF;

const char *EVP_KDF_get_name(Crypt::OpenSSL3::KDF kdf)

const char *EVP_KDF_get_description(Crypt::OpenSSL3::KDF kdf)

bool EVP_KDF_is_a(Crypt::OpenSSL3::KDF kdf, const char *name)

void EVP_KDF_names_list_all(Crypt::OpenSSL3::KDF kdf)
PPCODE:
	PUTBACK;
	EVP_KDF_names_do_all(kdf, EVP_name_callback, iTHX);
	SPAGAIN;

void EVP_KDF_list_all_provided(classname)
PPCODE:
	PUTBACK;
	EVP_KDF_do_all_provided(NULL, EVP_KDF_provided_callback, iTHX);
	SPAGAIN;

SV* EVP_KDF_get_param(Crypt::OpenSSL3::KDF kdf, const char* name)
CODE:
	GENERATE_GET_PARAM(EVP_KDF, kdf, name)
OUTPUT: RETVAL


MODULE = Crypt::OpenSSL3	PACKAGE = Crypt::OpenSSL3::KDF::Context	PREFIX = EVP_KDF_CTX_

Crypt::OpenSSL3::KDF::Context EVP_KDF_CTX_new(classname, Crypt::OpenSSL3::KDF ctx)
C_ARGS: ctx

Crypt::OpenSSL3::KDF::Context EVP_KDF_CTX_dup(Crypt::OpenSSL3::KDF::Context ctx)

void EVP_KDF_CTX_reset(Crypt::OpenSSL3::KDF::Context ctx)

size_t EVP_KDF_CTX_get_kdf_size(Crypt::OpenSSL3::KDF::Context ctx)

bool EVP_KDF_CTX_set_params(Crypt::OpenSSL3::KDF::Context ctx, PARAMS(EVP_KDF_CTX) params = NULL)

SV* EVP_KDF_CTX_get_param(Crypt::OpenSSL3::KDF::Context ctx, const char* name)
CODE:
	GENERATE_GET_PARAM(EVP_KDF_CTX, ctx, name)
OUTPUT: RETVAL

Crypt::OpenSSL3::KDF EVP_KDF_CTX_kdf(Crypt::OpenSSL3::KDF::Context ctx)
POSTCALL:
	EVP_KDF_up_ref(RETVAL);


MODULE = Crypt::OpenSSL3	PACKAGE = Crypt::OpenSSL3::KDF::Context	PREFIX = EVP_KDF_

NO_OUTPUT bool EVP_KDF_derive(Crypt::OpenSSL3::KDF::Context ctx, OUTLIST SV* derived, size_t keylen, PARAMS(EVP_KDF_CTX) params)
INIT:
	unsigned char* ptr = make_buffer(&derived, keylen);
C_ARGS: ctx, ptr, keylen, params
POSTCALL:
	if (RETVAL)
		set_buffer_length(derived, keylen);



MODULE = Crypt::OpenSSL3	PACKAGE = Crypt::OpenSSL3::Signature	PREFIX = EVP_SIGNATURE_

Crypt::OpenSSL3::Signature EVP_SIGNATURE_fetch(classname, const char* algorithm, const char* properties = "")
C_ARGS: NULL, algorithm, properties
POSTCALL:
	if (RETVAL == NULL)
		XSRETURN_UNDEF;

const char *EVP_SIGNATURE_get_name(Crypt::OpenSSL3::Signature signature)

const char *EVP_SIGNATURE_get_description(Crypt::OpenSSL3::Signature signature)

bool EVP_SIGNATURE_is_a(Crypt::OpenSSL3::Signature signature, const char *name)

void EVP_SIGNATURE_names_list_all(Crypt::OpenSSL3::Signature signature)
PPCODE:
	PUTBACK;
	EVP_SIGNATURE_names_do_all(signature, EVP_name_callback, iTHX);
	SPAGAIN;

void EVP_SIGNATURE_list_all_provided(classname)
PPCODE:
	PUTBACK;
	EVP_SIGNATURE_do_all_provided(NULL, EVP_SIGNATURE_provided_callback, iTHX);
	SPAGAIN;


MODULE = Crypt::OpenSSL3	PACKAGE = Crypt::OpenSSL3::PKey	PREFIX = EVP_PKEY_

BOOT:
{
	HV* stash = gv_stashpvs("Crypt::OpenSSL3::PKey", GV_ADD | GV_ADDMULTI);
	CONSTANT2(EVP_PKEY_, KEY_PARAMETERS);
	CONSTANT2(EVP_PKEY_, PUBLIC_KEY);
	CONSTANT2(EVP_PKEY_, KEYPAIR);
}

Crypt::OpenSSL3::PKey EVP_PKEY_new(classname)
C_ARGS:

Crypt::OpenSSL3::PKey EVP_PKEY_new_raw_private_key(classname, const char *keytype, const unsigned char *key, size_t length(key), const char *propq = "")
C_ARGS: NULL, keytype, propq, key, XSauto_length_of_key
POSTCALL:
	if (RETVAL == NULL)
		XSRETURN_UNDEF;

Crypt::OpenSSL3::PKey EVP_PKEY_new_raw_public_key(classname, const char *keytype, const unsigned char *key, size_t length(key), const char *propq = "")
C_ARGS: NULL, keytype, propq, key, XSauto_length_of_key
POSTCALL:
	if (RETVAL == NULL)
		XSRETURN_UNDEF;

Crypt::OpenSSL3::PKey EVP_PKEY_dup(Crypt::OpenSSL3::PKey ctx)

bool EVP_PKEY_eq(Crypt::OpenSSL3::PKey a, Crypt::OpenSSL3::PKey b)

bool EVP_PKEY_parameters_eq(Crypt::OpenSSL3::PKey a, Crypt::OpenSSL3::PKey b)

NO_OUTPUT void EVP_PKEY_get_raw_private_key(Crypt::OpenSSL3::PKey pkey, OUTLIST SV* key)
CODE:
	size_t length;
	int result = EVP_PKEY_get_raw_private_key(pkey, NULL, &length);
	if (!result)
		XSRETURN_UNDEF;
	unsigned char* ptr = make_buffer(&key, length);
	result = EVP_PKEY_get_raw_private_key(pkey, ptr, &length);
	if (result)
		set_buffer_length(key, length);


NO_OUTPUT void EVP_PKEY_get_raw_public_key(Crypt::OpenSSL3::PKey pkey, OUTLIST SV* key)
CODE:
	size_t length;
	int result = EVP_PKEY_get_raw_public_key(pkey, NULL, &length);
	if (!result)
		XSRETURN_UNDEF;
	unsigned char* ptr = make_buffer(&key, length);
	result = EVP_PKEY_get_raw_public_key(pkey, ptr, &length);
	if (result)
		set_buffer_length(key, length);

Crypt::OpenSSL3::PKey EVP_PKEY_read_pem_private_key(Crypt::OpenSSL3::BIO bio, SV* password_cb = undef, const char* propq = "")

lib/Crypt/OpenSSL3.xs view on Meta::CPAN

Crypt::OpenSSL3::PKey EVP_PKEY_decode_der_public_key(class, ASN1_DECODER* buffer)
CODE:
	RETVAL = d2i_PUBKEY(NULL, &buffer->ptr, buffer->end - buffer->ptr);
	if (!RETVAL)
		XSRETURN_UNDEF;
OUTPUT: RETVAL

SV* EVP_PKEY_encode_der_public_key(Crypt::OpenSSL3::PKey x)
CODE:
	int length = i2d_PUBKEY(x, NULL);
	if (length > 0) {
		unsigned char* ptr = make_buffer(&RETVAL, length);
		i2d_PUBKEY(x, &ptr);
		set_buffer_length(RETVAL, length);
	} else
		RETVAL = &PL_sv_undef;
OUTPUT: RETVAL

Crypt::OpenSSL3::PKey EVP_PKEY_decode_der_private_key(class, ASN1_DECODER* buffer)
CODE:
	RETVAL = d2i_AutoPrivateKey(NULL, &buffer->ptr, buffer->end - buffer->ptr);
	if (!RETVAL)
		XSRETURN_UNDEF;
OUTPUT: RETVAL

SV* EVP_PKEY_encode_der_private_key(Crypt::OpenSSL3::PKey x)
CODE:
	int length = i2d_PrivateKey(x, NULL);
	if (length > 0) {
		unsigned char* ptr = make_buffer(&RETVAL, length);
		i2d_PrivateKey(x, &ptr);
		set_buffer_length(RETVAL, length);
	} else
		RETVAL = &PL_sv_undef;
OUTPUT: RETVAL

Crypt::OpenSSL3::NID EVP_PKEY_get_id(Crypt::OpenSSL3::PKey pkey)
POSTCALL:
	if (RETVAL == -1)
		XSRETURN_UNDEF;

Crypt::OpenSSL3::NID EVP_PKEY_get_base_id(Crypt::OpenSSL3::PKey pkey)

int EVP_PKEY_type(int type)

bool EVP_PKEY_set_type(Crypt::OpenSSL3::PKey pkey, int type)

bool EVP_PKEY_set_type_str(Crypt::OpenSSL3::PKey pkey, const char *str, int length(str))

int EVP_PKEY_get_size(Crypt::OpenSSL3::PKey pkey)

int EVP_PKEY_get_bits(Crypt::OpenSSL3::PKey pkey)

int EVP_PKEY_get_security_bits(Crypt::OpenSSL3::PKey pkey)

bool EVP_PKEY_is_a(Crypt::OpenSSL3::PKey pkey, const char *name)

bool EVP_PKEY_can_sign(Crypt::OpenSSL3::PKey pkey)

void EVP_PKEY_type_names_list_all(Crypt::OpenSSL3::PKey pkey)
PPCODE:
	PUTBACK;
	EVP_PKEY_type_names_do_all(pkey, EVP_name_callback, iTHX);
	SPAGAIN;

const char *EVP_PKEY_get_type_name(Crypt::OpenSSL3::PKey key)

const char *EVP_PKEY_get_description(Crypt::OpenSSL3::PKey key)

Success EVP_PKEY_digestsign_supports_digest(Crypt::OpenSSL3::PKey pkey, const char *name, const char *propq)
C_ARGS: pkey, NULL, name, propq

NO_OUTPUT int EVP_PKEY_get_default_digest_name(Crypt::OpenSSL3::PKey pkey, OUTLIST SV* mdname)
INIT:
	char* ptr = (char*)make_buffer(&mdname, 32);
C_ARGS: pkey, ptr, 32
POSTCALL:
	if (RETVAL > 0)
		set_buffer_length(mdname, strlen(SvPV_nolen(mdname)));

NO_OUTPUT int EVP_PKEY_get_default_digest_nid(Crypt::OpenSSL3::PKey pkey, OUTLIST Crypt::OpenSSL3::NID pnid)
POSTCALL:
	if (RETVAL <= 0)
		XSRETURN_UNDEF;

int EVP_PKEY_get_field_type(Crypt::OpenSSL3::PKey pkey)

int EVP_PKEY_get_ec_point_conv_form(Crypt::OpenSSL3::PKey pkey)

NO_OUTPUT int EVP_PKEY_get_group_name(Crypt::OpenSSL3::PKey pkey, OUTLIST SV* name, size_t size = 32)
INIT:
	char* ptr = (char*)make_buffer(&name, size);
C_ARGS: pkey, ptr, size, &size
POSTCALL:
	if (RETVAL)
		set_buffer_length(name, size);

bool EVP_PKEY_set_encoded_public_key(Crypt::OpenSSL3::PKey pkey, const unsigned char *pub, size_t length(pub))

NO_OUTPUT size_t EVP_PKEY_get_encoded_public_key(Crypt::OpenSSL3::PKey pkey, OUTLIST SV* result)
INIT:
	unsigned char* ptr = NULL;
C_ARGS: pkey, &ptr
POSTCALL:
	result = RETVAL > 0 ? newSVpvn((char*)ptr, RETVAL) : &PL_sv_undef;
	OPENSSL_free(ptr);

SV* EVP_PKEY_get_param(Crypt::OpenSSL3::PKey pkey, const char* name)
CODE:
	GENERATE_GET_PARAM(EVP_PKEY, pkey, name)
OUTPUT: RETVAL

bool EVP_PKEY_get_int_param(Crypt::OpenSSL3::PKey pkey, const char *key_name, OUT int out)

bool EVP_PKEY_get_size_t_param(Crypt::OpenSSL3::PKey pkey, const char *key_name, OUT size_t out)

bool EVP_PKEY_get_bn_param(Crypt::OpenSSL3::PKey pkey, const char *key_name, OUT Crypt::OpenSSL3::BigNum bn)

bool EVP_PKEY_get_utf8_string_param(Crypt::OpenSSL3::PKey pkey, const char *key_name, char *str, size_t length(str), OUT size_t out_len)

bool EVP_PKEY_get_octet_string_param(Crypt::OpenSSL3::PKey pkey, const char *key_name, unsigned char *buf, size_t length(buf), OUT size_t out_len)

( run in 1.210 second using v1.01-cache-2.11-cpan-92ad3014f07 )