Crypt-OpenSSL3

 view release on metacpan or  search on metacpan

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

#define SSL_SESSION_set_time SSL_SESSION_set_time_ex
#endif


#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_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

#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

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

static unsigned char* S_make_buffer(pTHX_ SV** retval, size_t size) {
	*retval = newSVpv("", 0);
	char* ptr = SvGROW(*retval, size);
	return (unsigned char*)ptr;
}
#define make_buffer(svp, size) S_make_buffer(aTHX_ svp, size)

static char* S_grow_buffer(pTHX_ SV* buffer, size_t size) {
	SvUPGRADE(buffer, SVt_PV);
	SV_CHECK_THINKFIRST(buffer);
	return SvGROW(buffer, size);
}
#define grow_buffer(sv, size) S_grow_buffer(aTHX_ sv, size)

static inline void S_set_buffer_length(pTHX_ SV* buffer, ssize_t result) {
	SvCUR_set(buffer, result);
	SvPOK_only(buffer);
}
#define set_buffer_length(buffer, result) S_set_buffer_length(aTHX_ buffer, result)

static OSSL_PARAM* S_params_for(pTHX_ const OSSL_PARAM* settable, SV* input) {
	if (!SvROK(input) || SvTYPE(SvRV(input)) != SVt_PVHV)
		return NULL;

	OSSL_PARAM_BLD* builder = OSSL_PARAM_BLD_new();
	HV* hash = (HV*)SvRV(input);

	hv_iterinit(hash);
	char* name;
	I32 name_len;
	SV* sv;

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

POSTCALL:
	RETVAL = X509_ALGOR_dup(RETVAL);

Crypt::OpenSSL3::ASN1::Time X509_get_notBefore(Crypt::OpenSSL3::X509 x)
POSTCALL:
	RETVAL = ASN1_TIME_dup(RETVAL);

Crypt::OpenSSL3::ASN1::Time X509_get_notAfter(Crypt::OpenSSL3::X509 x)
POSTCALL:
	RETVAL = ASN1_TIME_dup(RETVAL);

bool X509_set_notBefore(Crypt::OpenSSL3::X509 x, Crypt::OpenSSL3::ASN1::Time tm)

bool X509_set_notAfter(Crypt::OpenSSL3::X509 x, Crypt::OpenSSL3::ASN1::Time 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);

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)

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);

Crypt::OpenSSL3::ASN1::String::Octet X509_digest_sig(Crypt::OpenSSL3::X509 cert)
C_ARGS: cert, NULL, NULL

Crypt::OpenSSL3::ASN1::String::Octet X509_get_distinguishing_id(Crypt::OpenSSL3::X509 x)

void X509_set_distinguishing_id(Crypt::OpenSSL3::X509 x, Crypt::OpenSSL3::ASN1::String::Octet distid)
INIT:
	distid = ASN1_OCTET_STRING_dup(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)

Crypt::OpenSSL3::ASN1::String::Octet X509_get_subject_key_id(Crypt::OpenSSL3::X509 x)
POSTCALL:
	RETVAL = ASN1_OCTET_STRING_dup(RETVAL);

Crypt::OpenSSL3::ASN1::String::Octet X509_get_authority_key_id(Crypt::OpenSSL3::X509 x)
POSTCALL:
	RETVAL = ASN1_OCTET_STRING_dup(RETVAL);

#if 0
Crypt::OpenSSL3::X509::GeneralName X509_get0_authority_issuer(Crypt::OpenSSL3::X509 x)
#endif

Crypt::OpenSSL3::ASN1::Integer X509_get_authority_serial(Crypt::OpenSSL3::X509 x)
POSTCALL:
	RETVAL = ASN1_INTEGER_dup(RETVAL);

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)

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

int X509_get_ext_by_NID(Crypt::OpenSSL3::X509 x, int nid, int lastpos = -1)

int X509_get_ext_by_OBJ(Crypt::OpenSSL3::X509 x, Crypt::OpenSSL3::ASN1::Object obj, int lastpos = -1)

int X509_get_ext_by_critical(Crypt::OpenSSL3::X509 x, int crit, int lastpos = -1)

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)

Crypt::OpenSSL3::ASN1::Integer X509_get_serialNumber(Crypt::OpenSSL3::X509 x)

bool X509_set_serialNumber(Crypt::OpenSSL3::X509 x, Crypt::OpenSSL3::ASN1::Integer serial)


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

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, SvPV_nolen(buffer), 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

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(SV* 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(SV* 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_

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

Crypt::OpenSSL3::PKey EVP_PKEY_new_raw_private_key(SV* 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(SV* 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

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

int 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 int pnid)
POSTCALL: