Crypt-OpenSSL3

 view release on metacpan or  search on metacpan

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

#define NID_eq(left, right) (left == right)
#define NID_raw(nid) nid
#define NID_is_undef(nid) (nid == NID_undef)

#define SSL_CIPHER_get_handshake_digest(c) (EVP_MD*)SSL_CIPHER_get_handshake_digest(c)

#define RAND_get_primary RAND_get0_primary
#define RAND_get_public RAND_get0_public
#define RAND_get_private RAND_get0_private
#define RAND_set_public RAND_set0_public
#define RAND_set_private RAND_set0_private
#define EVP_RAND_get_name EVP_RAND_get0_name
#define EVP_RAND_get_description EVP_RAND_get0_description
#define EVP_RAND_CTX_get_rand EVP_RAND_CTX_get0_rand
#define EVP_CIPHER_get_name EVP_CIPHER_get0_name
#define EVP_CIPHER_get_description EVP_CIPHER_get0_description
#undef EVP_CIPHER_CTX_init
#define EVP_CIPHER_CTX_init EVP_CipherInit_ex2
#define EVP_CIPHER_CTX_update EVP_CipherUpdate
#define EVP_CIPHER_CTX_final EVP_CipherFinal_ex
#define EVP_CIPHER_CTX_set_aead_ivlen(ctx, length) EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_IVLEN, length, NULL)
#define EVP_CIPHER_CTX_get_aead_tag(ctx, ptr, length) EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_GET_TAG, length, ptr)
#define EVP_CIPHER_CTX_set_aead_tag(ctx, ptr, length) EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_TAG, length, ptr)
#define EVP_CIPHER_CTX_get_name EVP_CIPHER_CTX_get0_name
#define EVP_CIPHER_CTX_get_cipher EVP_CIPHER_CTX_get1_cipher

#define EVP_MD_digest EVP_Digest
#define EVP_MD_get_name EVP_MD_get0_name
#define EVP_MD_get_description EVP_MD_get0_description
#undef EVP_MD_CTX_init
#define EVP_MD_CTX_get_md EVP_MD_CTX_get1_md
#define EVP_MD_CTX_get_name EVP_MD_CTX_get0_name
#define EVP_MD_CTX_init EVP_DigestInit_ex2
#define EVP_MD_CTX_update EVP_DigestUpdate
#define EVP_MD_CTX_final EVP_DigestFinal_ex
#define EVP_MD_CTX_final_xof EVP_DigestFinalXOF
#define EVP_MD_CTX_squeeze EVP_DigestSqueeze
#define EVP_MD_CTX_sign_init EVP_DigestSignInit
#define EVP_MD_CTX_sign_init_ex EVP_DigestSignInit_ex
#define EVP_MD_CTX_sign_update EVP_DigestSignUpdate
#define EVP_MD_CTX_sign_final EVP_DigestSignFinal
#define EVP_MD_CTX_sign EVP_DigestSign
#define EVP_MD_CTX_verify_init EVP_DigestVerifyInit
#define EVP_MD_CTX_verify_update EVP_DigestVerifyUpdate
#define EVP_MD_CTX_verify_final EVP_DigestVerifyFinal
#define EVP_MD_CTX_verify EVP_DigestVerify

#define EVP_MAC_get_name EVP_MAC_get0_name
#define EVP_MAC_get_description EVP_MAC_get0_description
#define EVP_MAC_CTX_get_mac EVP_MAC_CTX_get0_mac
#define EVP_MAC_CTX_get_name EVP_MAC_CTX_get0_name

#define EVP_KDF_get_name EVP_KDF_get0_name
#define EVP_KDF_get_description EVP_KDF_get0_description
#define EVP_KDF_CTX_get_name EVP_KDF_CTX_get0_name
#define EVP_KDF_CTX_kdf(ctx) (EVP_KDF*)EVP_KDF_CTX_kdf(ctx)

#define EVP_SIGNATURE_get_name EVP_SIGNATURE_get0_name
#define EVP_SIGNATURE_get_description EVP_SIGNATURE_get0_description

#define EVP_PKEY_read_pem_private_key PEM_read_bio_PrivateKey_ex
#define EVP_PKEY_write_pem_private_key PEM_write_bio_PrivateKey_ex
#define EVP_PKEY_read_pem_public_key PEM_read_bio_PUBKEY_ex
#define EVP_PKEY_write_pem_public_key PEM_write_bio_PUBKEY_ex
#define EVP_PKEY_read_der_private_key d2i_PrivateKey_ex_bio
#define EVP_PKEY_write_der_private_key i2d_PrivateKey_bio
#if !OPENSSL_VERSION_PREREQ(3, 2)
#define d2i_PUBKEY_ex_bio(bio, ptr, lib, propq) d2i_PUBKEY_bio(bio, ptr)
#endif
#define EVP_PKEY_read_der_public_key d2i_PUBKEY_ex_bio
#define EVP_PKEY_write_der_public_key i2d_PUBKEY_bio
#define EVP_PKEY_new_raw_private_key EVP_PKEY_new_raw_private_key_ex
#define EVP_PKEY_new_raw_public_key EVP_PKEY_new_raw_public_key_ex
#define EVP_PKEY_get_description EVP_PKEY_get0_description
#define EVP_PKEY_get_type_name EVP_PKEY_get0_type_name
#define EVP_PKEY_get_encoded_public_key EVP_PKEY_get1_encoded_public_key
#define EVP_PKEY_set_encoded_public_key EVP_PKEY_set1_encoded_public_key
#define EVP_PKEY_encrypt_init EVP_PKEY_encrypt_init_ex
#define EVP_PKEY_decrypt_init EVP_PKEY_decrypt_init_ex
#define EVP_PKEY_derive_init EVP_PKEY_derive_init_ex
#define EVP_PKEY_derive_set_peer EVP_PKEY_derive_set_peer_ex
#define EVP_PKEY_CTX_get_pkey EVP_PKEY_CTX_get0_pkey
#define EVP_PKEY_CTX_get_peerkey EVP_PKEY_CTX_get0_peerkey

#if !OPENSSL_VERSION_PREREQ(3, 4)
static int EVP_PKEY_sign_init_ex2(EVP_PKEY_CTX *ctx, EVP_SIGNATURE *algo, const OSSL_PARAM params[]) {
	if (algo)
		return FALSE;
	return EVP_PKEY_sign_init_ex(ctx, params);
}

static int EVP_PKEY_verify_init_ex2(EVP_PKEY_CTX *ctx, EVP_SIGNATURE *algo, const OSSL_PARAM params[]) {
	if (algo)
		return FALSE;
	return EVP_PKEY_verify_init_ex(ctx, params);
}
#endif
#define EVP_PKEY_sign_init EVP_PKEY_sign_init_ex2
#define EVP_PKEY_verify_init EVP_PKEY_verify_init_ex2


#if OPENSSL_VERSION_PREREQ(3, 2)
#define OSSL_HPKE_CTX_set_authpriv OSSL_HPKE_CTX_set1_authpriv
#define OSSL_HPKE_CTX_set_authpub OSSL_HPKE_CTX_set1_authpub
#define OSSL_HPKE_CTX_set_psk OSSL_HPKE_CTX_set1_psk
#define OSSL_HPKE_CTX_set_ikme OSSL_HPKE_CTX_set1_ikme
#define OSSL_HPKE_decapsulate OSSL_HPKE_decap
#define OSSL_HPKE_check OSSL_HPKE_suite_check
#define OSSL_HPKE_kem_id(suite) (suite)->kem_id
#define OSSL_HPKE_kdf_id(suite) (suite)->kdf_id
#define OSSL_HPKE_aead_id(suite) (suite)->aead_id
#endif

#define CONSTANT2(PREFIX, VALUE) newCONSTSUB(stash, #VALUE, newSVuv(PREFIX##VALUE))

#define STACK_TO_STACK(TYPE, stack) \
	if (stack) {\
		int num = sk_ ## TYPE ## _num(stack);\
		EXTEND(SP, num);\
		for (int i = 0; i < num; ++i) {\
			TYPE* value = sk_ ## TYPE ## _delete(stack, 0);\
			mPUSHs(make_ ## TYPE(aTHX_ value));\
		}\
		sk_ ## TYPE ## _free(stack);\
	}

#define CSTACK_TO_STACK(TYPE, stack) \
	if (stack) {\
		int num = sk_ ## TYPE ## _num(stack);\
		EXTEND(SP, num);\
		for (int i = 0; i < num; ++i) {\
			TYPE* orig = sk_ ## TYPE ## _value(stack, i);\

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

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:

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

		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)


MODULE = Crypt::OpenSSL3	PACKAGE = Crypt::OpenSSL3::X509::Transparency::Log::Store	PREFIX = CTLOG_STORE_

Crypt::OpenSSL3::X509::Transparency::Log::Store CTLOG_STORE_new(const char *propq = NULL)
C_ARGS: NULL, propq

#if OPENSSL_VERSION_PREREQ(4, 1)
bool CTLOG_STORE_add_log_key(Crypt::OpenSSL3::X509::Transparency::Log::Store store, Crypt::OpenSSL3::PKey pkey, const char* name, const char* propq = NULL)
CODE:
	CTLOG* log = CTLOG_new_ex(pkey, name, NULL, propq);
	RETVAL = CTLOG_STORE_add0_log(store, log);
OUTPUT: RETVAL

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

bool SSL_CTX_set_session_id_context(Crypt::OpenSSL3::SSL::Context ctx, const unsigned char *sid_ctx, unsigned int length(sid_ctx))

long SSL_CTX_set_mode(Crypt::OpenSSL3::SSL::Context ctx, long mode)

long SSL_CTX_clear_mode(Crypt::OpenSSL3::SSL::Context ctx, long mode)

long SSL_CTX_get_mode(Crypt::OpenSSL3::SSL::Context ctx)

bool SSL_CTX_set_min_proto_version(Crypt::OpenSSL3::SSL::Context ctx, int version)

bool SSL_CTX_set_max_proto_version(Crypt::OpenSSL3::SSL::Context ctx, int version)

int SSL_CTX_get_min_proto_version(Crypt::OpenSSL3::SSL::Context ctx)

int SSL_CTX_get_max_proto_version(Crypt::OpenSSL3::SSL::Context ctx)

bool SSL_CTX_set_alpn_protos(Crypt::OpenSSL3::SSL::Context ctx, const unsigned char *protos, unsigned int length(protos))

Crypt::OpenSSL3::X509::Store SSL_CTX_get_cert_store(Crypt::OpenSSL3::SSL::Context ctx)
POSTCALL:
	X509_STORE_up_ref(RETVAL);

void SSL_CTX_set_cert_store(Crypt::OpenSSL3::SSL::Context ctx, Crypt::OpenSSL3::X509::Store store)
POSTCALL:
	X509_STORE_up_ref(store);

bool SSL_CTX_load_verify_locations(Crypt::OpenSSL3::SSL::Context ctx, const char *CAfile, const char *CApath)

bool SSL_CTX_load_verify_file(Crypt::OpenSSL3::SSL::Context ctx, const char *CAfile)

bool SSL_CTX_load_verify_dir(Crypt::OpenSSL3::SSL::Context ctx, const char *CApath)

bool SSL_CTX_load_verify_store(Crypt::OpenSSL3::SSL::Context ctx, const char *CAstore)

bool SSL_CTX_set_default_verify_paths(Crypt::OpenSSL3::SSL::Context ctx)

bool SSL_CTX_set_default_verify_dir(Crypt::OpenSSL3::SSL::Context ctx)

bool SSL_CTX_set_default_verify_file(Crypt::OpenSSL3::SSL::Context ctx)

bool SSL_CTX_use_certificate(Crypt::OpenSSL3::SSL::Context ctx, Crypt::OpenSSL3::X509 x)

bool SSL_CTX_use_certificate_ASN1(Crypt::OpenSSL3::SSL::Context ctx, int length(d), const unsigned char *d)

bool SSL_CTX_use_certificate_file(Crypt::OpenSSL3::SSL::Context ctx, const char *file, int type)

bool SSL_CTX_use_certificate_chain_file(Crypt::OpenSSL3::SSL::Context ctx, const char *file)

long SSL_CTX_add_extra_chain_cert(Crypt::OpenSSL3::SSL::Context ctx, Crypt::OpenSSL3::X509 x509)

long SSL_CTX_clear_extra_chain_certs(Crypt::OpenSSL3::SSL::Context ctx)

bool SSL_CTX_use_PrivateKey(Crypt::OpenSSL3::SSL::Context ctx, Crypt::OpenSSL3::PKey pkey)

bool SSL_CTX_use_PrivateKey_ASN1(Crypt::OpenSSL3::SSL::Context ctx, int pk, const unsigned char *d, long length(d))
C_ARGS: pk, ctx, d, XSauto_length_of_d

bool SSL_CTX_use_PrivateKey_file(Crypt::OpenSSL3::SSL::Context ctx, const char *file, int type)

bool SSL_CTX_check_private_key(Crypt::OpenSSL3::SSL::Context ctx)

void SSL_CTX_set_verify(Crypt::OpenSSL3::SSL::Context ctx, int mode)
C_ARGS: ctx, mode, NULL

void SSL_CTX_set_verify_depth(Crypt::OpenSSL3::SSL::Context ctx, int depth)

void SSL_CTX_set_post_handshake_auth(Crypt::OpenSSL3::SSL::Context ctx, int val)

bool SSL_CTX_set_cipher_list(Crypt::OpenSSL3::SSL::Context ctx, const char *str)

bool SSL_CTX_set_ciphersuites(Crypt::OpenSSL3::SSL::Context ctx, const char *str)

Crypt::OpenSSL3::X509::VerifyParam SSL_CTX_get_param(Crypt::OpenSSL3::SSL::Context ctx)

bool SSL_CTX_set_param(Crypt::OpenSSL3::SSL::Context ctx, Crypt::OpenSSL3::X509::VerifyParam vpm);

int SSL_CTX_add_client_CA(Crypt::OpenSSL3::SSL::Context ctx, Crypt::OpenSSL3::X509 cacert)
POSTCALL:
	X509_up_ref(cacert);

bool SSL_CTX_add_session(Crypt::OpenSSL3::SSL::Context ctx, Crypt::OpenSSL3::SSL::Session c);

bool SSL_CTX_remove_session(Crypt::OpenSSL3::SSL::Context ctx, Crypt::OpenSSL3::SSL::Session c);

long SSL_CTX_sess_number(Crypt::OpenSSL3::SSL::Context ctx)

long SSL_CTX_sess_connect(Crypt::OpenSSL3::SSL::Context ctx)

long SSL_CTX_sess_connect_good(Crypt::OpenSSL3::SSL::Context ctx)

long SSL_CTX_sess_connect_renegotiate(Crypt::OpenSSL3::SSL::Context ctx)

long SSL_CTX_sess_accept(Crypt::OpenSSL3::SSL::Context ctx)

long SSL_CTX_sess_accept_good(Crypt::OpenSSL3::SSL::Context ctx)

long SSL_CTX_sess_accept_renegotiate(Crypt::OpenSSL3::SSL::Context ctx)

long SSL_CTX_sess_hits(Crypt::OpenSSL3::SSL::Context ctx)

long SSL_CTX_sess_cb_hits(Crypt::OpenSSL3::SSL::Context ctx)

long SSL_CTX_sess_misses(Crypt::OpenSSL3::SSL::Context ctx)

long SSL_CTX_sess_timeouts(Crypt::OpenSSL3::SSL::Context ctx)

long SSL_CTX_sess_cache_full(Crypt::OpenSSL3::SSL::Context ctx)

long SSL_CTX_sess_set_cache_size(Crypt::OpenSSL3::SSL::Context ctx, long t)

long SSL_CTX_sess_get_cache_size(Crypt::OpenSSL3::SSL::Context ctx)

int SSL_CTX_set_num_tickets(Crypt::OpenSSL3::SSL::Context ctx, size_t num_tickets)

size_t SSL_CTX_get_num_tickets(Crypt::OpenSSL3::SSL::Context ctx)

#if OPENSSL_VERSION_PREREQ(3, 5)

bool SSL_CTX_set_domain_flags(Crypt::OpenSSL3::SSL::Context ctx, uint64_t flags)

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

NO_OUTPUT int SSL_get_event_timeout(Crypt::OpenSSL3::SSL s, OUTLIST struct timeval tv, OUTLIST Bool is_infinite)
INIT:
	is_infinite = 0;
POSTCALL:
	if (!RETVAL)
		XSRETURN_EMPTY;

bool SSL_handle_events(Crypt::OpenSSL3::SSL ssl)

long SSL_set_options(Crypt::OpenSSL3::SSL ssl, long options)

long SSL_clear_options(Crypt::OpenSSL3::SSL ssl, long options)

long SSL_get_options(Crypt::OpenSSL3::SSL ssl)

bool SSL_set_session_id_context(Crypt::OpenSSL3::SSL ssl, const unsigned char *sid_ctx, unsigned int length(sid_ctx))

long SSL_set_mode(Crypt::OpenSSL3::SSL ssl, long mode)

long SSL_clear_mode(Crypt::OpenSSL3::SSL ssl, long mode)

long SSL_get_mode(Crypt::OpenSSL3::SSL ssl)

bool SSL_set_min_proto_version(Crypt::OpenSSL3::SSL ssl, int version)

bool SSL_set_max_proto_version(Crypt::OpenSSL3::SSL ssl, int version)

int SSL_get_min_proto_version(Crypt::OpenSSL3::SSL ssl)

int SSL_get_max_proto_version(Crypt::OpenSSL3::SSL ssl)

void SSL_set_security_level(Crypt::OpenSSL3::SSL s, int level)

int SSL_get_security_level(Crypt::OpenSSL3::SSL s)

bool SSL_set_alpn_protos(Crypt::OpenSSL3::SSL ssl, ...)
CODE:
	SV* buffer = sv_2mortal(newSVpvs(""));
	static const char pattern[] = "(C/a)*";
	packlist(buffer, pattern, pattern + sizeof pattern - 1, &ST(1), &ST(items));
	STRLEN raw_len;
	const char* raw = SvPVbyte(buffer, raw_len);
	RETVAL = SSL_set_alpn_protos(ssl, (unsigned char*)raw, raw_len);
OUTPUT: RETVAL

bool SSL_use_certificate(Crypt::OpenSSL3::SSL ssl, Crypt::OpenSSL3::X509 x)

bool SSL_use_certificate_ASN1(Crypt::OpenSSL3::SSL ssl, const unsigned char *d, int length(d))

bool SSL_use_certificate_file(Crypt::OpenSSL3::SSL ssl, const char *file, int type)

bool SSL_use_certificate_chain_file(Crypt::OpenSSL3::SSL ssl, const char *file)

bool SSL_use_PrivateKey(Crypt::OpenSSL3::SSL ssl, Crypt::OpenSSL3::PKey pkey)

bool SSL_use_PrivateKey_ASN1(Crypt::OpenSSL3::SSL ssl, int pk, const unsigned char *d, long length(d))
C_ARGS: pk, ssl, d, XSauto_length_of_d

bool SSL_use_PrivateKey_file(Crypt::OpenSSL3::SSL ssl, const char *file, int type)

bool SSL_check_private_key(Crypt::OpenSSL3::SSL ssl)

void SSL_set_verify(Crypt::OpenSSL3::SSL ssl, int mode)
C_ARGS: ssl, mode, NULL

void SSL_set_verify_depth(Crypt::OpenSSL3::SSL ssl, int depth)

Crypt::OpenSSL3::X509::VerifyResult SSL_get_verify_result(Crypt::OpenSSL3::SSL ssl);

void SSL_set_post_handshake_auth(Crypt::OpenSSL3::SSL ssl, int val)

bool SSL_set_cipher_list(Crypt::OpenSSL3::SSL ssl, const char *str)

bool SSL_set_ciphersuites(Crypt::OpenSSL3::SSL ssl, const char *str)

const char *SSL_get_cipher_list(Crypt::OpenSSL3::SSL ssl, int priority)
POSTCALL:
	if (!RETVAL)
		XSRETURN_UNDEF;

Crypt::OpenSSL3::X509::VerifyParam SSL_get_param(Crypt::OpenSSL3::SSL ssl)

bool SSL_set_param(Crypt::OpenSSL3::SSL ssl, Crypt::OpenSSL3::X509::VerifyParam vpm);

int SSL_add_client_CA(Crypt::OpenSSL3::SSL ssl, Crypt::OpenSSL3::X509 cacert)
POSTCALL:
	X509_up_ref(cacert);

bool SSL_verify_client_post_handshake(Crypt::OpenSSL3::SSL ssl)

int SSL_get_error(Crypt::OpenSSL3::SSL ssl, int ret)

bool SSL_set_tlsext_host_name(Crypt::OpenSSL3::SSL s, const char *name)

const char* SSL_get_servername(Crypt::OpenSSL3::SSL s, int type)

int SSL_get_servername_type(Crypt::OpenSSL3::SSL s)

bool SSL_set_host(Crypt::OpenSSL3::SSL s, const char *hostname)

#if OPENSSL_VERSION_PREREQ(4, 0)
bool SSL_set_dnsname(Crypt::OpenSSL3::SSL s, const char *hostname)

bool SSL_set_ipaddr(Crypt::OpenSSL3::SSL s, const char *hostname)
#endif

int SSL_connect(Crypt::OpenSSL3::SSL ssl)

int SSL_accept(Crypt::OpenSSL3::SSL ssl)

int SSL_clear(Crypt::OpenSSL3::SSL ssl)

int SSL_do_handshake(Crypt::OpenSSL3::SSL ssl)

void SSL_set_connect_state(Crypt::OpenSSL3::SSL ssl)

void SSL_set_accept_state(Crypt::OpenSSL3::SSL ssl)

bool SSL_is_server(Crypt::OpenSSL3::SSL ssl)

int SSL_read(Crypt::OpenSSL3::SSL ssl, SV* buffer, size_t size)

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

	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 = "")
C_ARGS: bio, NULL, NULL, NULL, NULL, propq
POSTCALL:
	if (!RETVAL)
		XSRETURN_UNDEF;

bool EVP_PKEY_write_pem_private_key(Crypt::OpenSSL3::PKey pkey, Crypt::OpenSSL3::BIO bio, SV* cipher_sv = undef, SV* key = undef, const char* propq = "")
INIT:
	const EVP_CIPHER* cipher = SvOK(cipher_sv) ? get_EVP_CIPHER(aTHX_ cipher_sv) : NULL;
	STRLEN klen = 0;
	const unsigned char* kstr = NULL;
	if (SvOK(key))
		kstr = (unsigned char*)SvPV(key, klen);
C_ARGS: bio, pkey, cipher, kstr, klen, NULL, NULL, NULL, propq

Crypt::OpenSSL3::PKey EVP_PKEY_read_pem_public_key(Crypt::OpenSSL3::BIO bio, const char* propq = "")
C_ARGS: bio, NULL, NULL, NULL, NULL, propq
POSTCALL:
	if (!RETVAL)
		XSRETURN_UNDEF;

bool EVP_PKEY_write_pem_public_key(Crypt::OpenSSL3::PKey pkey, Crypt::OpenSSL3::BIO bio, const char* propq = "")
C_ARGS: bio, pkey, NULL, propq

Crypt::OpenSSL3::PKey EVP_PKEY_read_der_public_key(class, Crypt::OpenSSL3::BIO bio, const char* propq = NULL)
C_ARGS: bio, NULL, NULL, propq
POSTCALL:
	if (!RETVAL)
		XSRETURN_UNDEF;

Crypt::OpenSSL3::PKey EVP_PKEY_read_der_private_key(class, Crypt::OpenSSL3::BIO bio, const char* propq = NULL)
C_ARGS: bio, NULL, NULL, propq
POSTCALL:
	if (!RETVAL)
		XSRETURN_UNDEF;

bool EVP_PKEY_write_der_public_key(Crypt::OpenSSL3::PKey a, Crypt::OpenSSL3::BIO bio)
INTERFACE: EVP_PKEY_write_der_public_key EVP_PKEY_write_der_private_key
C_ARGS: bio, a

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)