File Coverage

lib/Crypt/OpenSSL3.xs

Criterion	Covered	Total	%
statement	199	566	35.1
branch	55	410	13.4
condition			n/a
subroutine			n/a
pod			n/a
total	254	976	26.0

line	stmt	bran	code
1			#define PERL_NO_GET_CONTEXT
2			#include "EXTERN.h"
3			#include "perl.h"
4			#include "XSUB.h"
5
6			#ifndef __bool_true_false_are_defined
7			#undef bool
8			#include
9			#endif
10
11			#define NEED_mg_findext
12			#include "ppport.h"
13
14			#include
15			#include
16			#include
17			#include
18			#include
19			#include
20
21			#include
22			#include
23			#include
24			#include
25
26			#define TYPE_TYPE(c_type, xs_type) typedef c_type * Crypt__OpenSSL3__ ## xs_type;
27			#define MAGIC_TABLE(xs_type, dup, free)\
28			static const MGVTBL Crypt__OpenSSL3__ ## xs_type ## _magic = {\
29			.svt_free = free,\
30			.svt_dup = dup,\
31			};
32
33			#define TYPE_COMMON(c_type, xs_type, p_type)\
34			static SV* make_ ## c_type(pTHX_ void* var) {\
35			SV* result = newSV(0);\
36			const char* classname = "Crypt::OpenSSL3::" #p_type;\
37			const MGVTBL* mgvtbl = &Crypt__OpenSSL3__## xs_type ##_magic;\
38			MAGIC* magic = sv_magicext(newSVrv(result, classname), NULL, PERL_MAGIC_ext, mgvtbl, (const char*)var, 0);\
39			magic->mg_flags \|= MGf_DUP;\
40			return result;\
41			}\
42			static c_type* get_ ## c_type (pTHX_ SV* value) {\
43			if (!SvROK(value))\
44			return NULL;\
45			MAGIC* magic = mg_findext(SvRV(value), PERL_MAGIC_ext, &Crypt__OpenSSL3__## xs_type ##_magic);\
46			return magic ? (c_type*)magic->mg_ptr : NULL;\
47			}
48
49			#define DUPLICATING_TYPE(c_type, xs_type, p_type)\
50			TYPE_TYPE(c_type, xs_type)\
51			static int c_type ## _magic_dup(pTHX_ MAGIC* mg, CLONE_PARAMS* params) {\
52			mg->mg_ptr = (char)c_type ## _dup((c_type)mg->mg_ptr);\
53			return 0;\
54			}\
55			static int c_type ## _magic_free(pTHX_ SV* sv, MAGIC* mg) {\
56			c_type ## _free((c_type*)mg->mg_ptr);\
57			return 0;\
58			}\
59			MAGIC_TABLE(xs_type, c_type ## _magic_dup, c_type ## _magic_free)\
60			TYPE_COMMON(c_type, xs_type, p_type)
61
62			#define COUNTING_TYPE(c_type, xs_type, p_type)\
63			typedef c_type * Crypt__OpenSSL3__ ## xs_type;\
64			static int c_type ## _magic_dup(pTHX_ MAGIC* mg, CLONE_PARAMS* params) {\
65			c_type ## _up_ref((c_type*)mg->mg_ptr);\
66			return 0;\
67			}\
68			static int c_type ## _magic_free(pTHX_ SV* sv, MAGIC* mg) {\
69			c_type ## _free((c_type*)mg->mg_ptr);\
70			return 0;\
71			}\
72			MAGIC_TABLE(xs_type, c_type ## _magic_dup, c_type ## _magic_free)\
73			TYPE_COMMON(c_type, xs_type, p_type)
74
75			#define SIMPLE_TYPE(c_type, xs_type, p_type, modifier)\
76			TYPE_TYPE(modifier c_type, xs_type)\
77			MAGIC_TABLE(xs_type, NULL, NULL)\
78			TYPE_COMMON(c_type, xs_type, p_type)
79
80			#if !OPENSSL_VERSION_PREREQ(3, 2)
81	0		static EVP_MD_CTX EVP_MD_CTX_dup(const EVP_MD_CTX in) {
82	0		EVP_MD_CTX* result = EVP_MD_CTX_new();
83	0		EVP_MD_CTX_copy(result, in);
84	0		return result;
85			}
86
87	0		static EVP_CIPHER_CTX EVP_CIPHER_CTX_dup(const EVP_CIPHER_CTX in) {
88	0		EVP_CIPHER_CTX* result = EVP_CIPHER_CTX_new();
89	0		EVP_CIPHER_CTX_copy(result, in);
90	0		return result;
91			}
92			#define EVP_RAND_CTX_up_ref(ctx) NULL
93			#endif
94
95			typedef unsigned long Crypt__OpenSSL3__Error;
96	0	0	COUNTING_TYPE(EVP_RAND, Random, Random)
	0	0
	0
	0
	0
97	0	0	COUNTING_TYPE(EVP_RAND_CTX, Random__Context, Random::Context)
	0	0
	0
	0
	0
98	249	0	COUNTING_TYPE(EVP_CIPHER, Cipher, Cipher)
	0	0
	124
	125
	0
99	2	0	DUPLICATING_TYPE(EVP_CIPHER_CTX, Cipher__Context, Cipher::Context)
	0	0
	0
	2
	0
100	45	0	COUNTING_TYPE(EVP_MD, MD, MD)
	0	0
	22
	23
	0
101	3	0	DUPLICATING_TYPE(EVP_MD_CTX, MD__Context, MD::Context)
	0	0
	0
	3
	0
102	19	0	COUNTING_TYPE(EVP_MAC, MAC, MAC)
	0	0
	9
	10
	0
103	1	0	DUPLICATING_TYPE(EVP_MAC_CTX, MAC__Context, MAC::Context)
	0	0
	0
	1
	0
104	25	0	COUNTING_TYPE(EVP_KDF, KDF, KDF)
	0	0
	12
	13
	0
105	1	0	DUPLICATING_TYPE(EVP_KDF_CTX, KDF__Context, KDF::Context)
	0	0
	0
	1
	0
106	0	0	COUNTING_TYPE(EVP_SIGNATURE, Signature, Signature)
	0	0
	0
	0
	0
107	2	0	DUPLICATING_TYPE(EVP_PKEY, PKey, PKey)
	0	0
	0
	2
	0
108	4	0	DUPLICATING_TYPE(EVP_PKEY_CTX, PKey__Context, PKey::Context)
	0	0
	0
	4
	0
109
110			typedef BIGNUM BN;
111	6	50	DUPLICATING_TYPE(BN, BigNum, BigNum);
	6	0
	0
	0
	0
112			#define BN_CTX_dup(old) BN_CTX_new()
113	0	0	DUPLICATING_TYPE(BN_CTX, BigNum__Context, BigNum::Context)
	0	0
	0
	0
	0
114	0	0	SIMPLE_TYPE(ASN1_OBJECT, ASN1__Object, ASN1::Object, )
	0	0
	0
115	0	0	DUPLICATING_TYPE(X509, X509, X509)
	0	0
	0
	0
	0
116	0	0	COUNTING_TYPE(X509_STORE, X509__Store, X509::Store)
	0	0
	0
	0
	0
117	0	0	DUPLICATING_TYPE(X509_NAME, X509__Name, X509::Name)
	0	0
	0
	0
	0
118	0	0	DUPLICATING_TYPE(X509_NAME_ENTRY, X509__Name__Entry, X509::Name::Entry)
	0	0
	0
	0
	0
119			typedef long Crypt__OpenSSL3__X509__VerifyResult;
120
121	2	0	COUNTING_TYPE(BIO, BIO, BIO)
	0	0
	0
	2
	0
122			#if OPENSSL_VERSION_PREREQ(3, 2)
123			DUPLICATING_TYPE(BIO_ADDR, BIO__Address, BIO::Address)
124			typedef BIO_POLL_DESCRIPTOR* Crypt__OpenSSL3__BIO__PollDescriptor;
125			#endif
126
127	0	0	SIMPLE_TYPE(SSL_METHOD, SSL__Method, SSL::Method, const)
	0	0
	0
128	1	0	COUNTING_TYPE(SSL_CTX, SSL__Context, SSL::Context)
	0	0
	0
	1
	0
129	2	0	COUNTING_TYPE(SSL, SSL, SSL)
	0	0
	0
	2
	0
130	0	0	DUPLICATING_TYPE(SSL_SESSION, SSL__Session, SSL::Session)
	0	0
	0
	0
	0
131	0	0	SIMPLE_TYPE(SSL_CIPHER, SSL__Cipher, SSL::Context, const)
	0	0
	0
132
133			#define PARAMS(a) OSSL_PARAM*
134			#define CTX_PARAMS(a) OSSL_PARAM*
135
136			#undef OPENSSL_VERSION_TEXT
137			#define OPENSSL_VERSION_TEXT OPENSSL_VERSION
138
139			#define BIO_new_mem() BIO_new(BIO_s_mem())
140			#define BIO_POLL_DESCRIPTOR_new(class) safecalloc(1, sizeof(BIO_POLL_DESCRIPTOR))
141			#define BIO_POLL_DESCRIPTOR_type(desc) ((desc)->type)
142			#define BIO_POLL_DESCRIPTOR_fd(desc) ((desc)->value.fd)
143
144			#define BN_generate_prime BN_generate_prime_ex2
145
146			#define X509_read_pem PEM_read_bio_X509
147			#define X509_write_pem PEM_write_bio_X509
148			#define X509_verify_cert_error_code(value) value
149			#define X509_verify_cert_ok(value) (value == X509_V_OK)
150
151			#define SSL_Method_TLS TLS_method
152			#define SSL_Method_TLS_server TLS_server_method
153			#define SSL_Method_TLS_client TLS_client_method
154
155			#define SSL_Method_DTLS DTLS_method
156			#define SSL_Method_DTLS_server DTLS_server_method
157			#define SSL_Method_DTLS_client DTLS_client_method
158
159			#define SSL_Method_QUIC_client OSSL_QUIC_client_method
160			#define SSL_Method_QUIC_client_thread OSSL_QUIC_client_thread_method
161			#define SSL_Method_QUIC_server OSSL_QUIC_server_method
162
163			#define SSL_set_host SSL_set1_host
164			#define SSL_set_rbio SSL_set0_rbio
165			#define SSL_set_wbio SSL_set0_wbio
166			#define SSL_get_context SSL_get_SSL_CTX
167			#define SSL_get_alpn_selected SSL_get0_alpn_selected
168			#define SSL_get_connection SSL_get0_connection
169			#define SSL_get_listener SSL_get0_listener
170			#define SSL_get_domain SSL_get0_domain
171			#define SSL_set_initial_peer_addr SSL_set1_initial_peer_addr
172			#if !OPENSSL_VERSION_PREREQ(3, 2)
173			#define SSL_is_tls(s) (!SSL_is_dtls(s))
174			#define SSL_is_quic(s) FALSE
175			#endif
176
177			#define SSL_SESSION_get_peer SSL_SESSION_get0_peer
178			#define SSL_SESSION_get_alpn_selected SSL_SESSION_get0_alpn_selected
179			#define SSL_SESSION_get_cipher SSL_SESSION_get0_cipher
180			#define SSL_SESSION_get_hostname SSL_SESSION_get0_hostname
181			#define SSL_SESSION_get_id_context SSL_SESSION_get0_id_context
182			#define SSL_SESSION_get_ticket SSL_SESSION_get0_ticket
183			#define SSL_SESSION_set_alpn_selected SSL_SESSION_set1_alpn_selected
184			#define SSL_SESSION_set_hostname SSL_SESSION_set1_hostname
185			#define SSL_SESSION_set_id SSL_SESSION_set1_id
186			#define SSL_SESSION_set_id_context SSL_SESSION_set1_id_context
187			#if !OPENSSL_VERSION_PREREQ(3,2)
188			#define SSL_get_event_timeout(s, tv, inf) DTLSv1_get_timeout(s, tv)
189			#define SSL_handle_events DTLSv1_handle_timeout
190			#endif
191			#if OPENSSL_VERSION_PREREQ(3, 3)
192			#define SSL_SESSION_get_time SSL_SESSION_get_time_ex
193			#define SSL_SESSION_set_time SSL_SESSION_set_time_ex
194			#endif
195
196
197			#define SSL_CIPHER_get_handshake_digest(c) (EVP_MD*)SSL_CIPHER_get_handshake_digest(c)
198
199			#define RAND_get_primary RAND_get0_primary
200			#define RAND_get_public RAND_get0_public
201			#define RAND_get_private RAND_get0_private
202			#define RAND_set_public RAND_set0_public
203			#define RAND_set_private RAND_set0_private
204			#define EVP_RAND_get_name EVP_RAND_get0_name
205			#define EVP_RAND_get_description EVP_RAND_get0_description
206			#define EVP_RAND_CTX_get_rand EVP_RAND_CTX_get0_rand
207			#define EVP_CIPHER_get_name EVP_CIPHER_get0_name
208			#define EVP_CIPHER_get_description EVP_CIPHER_get0_description
209			#undef EVP_CIPHER_CTX_init
210			#define EVP_CIPHER_CTX_init EVP_CipherInit_ex2
211			#define EVP_CIPHER_CTX_update EVP_CipherUpdate
212			#define EVP_CIPHER_CTX_final EVP_CipherFinal_ex
213			#define EVP_CIPHER_CTX_set_aead_ivlen(ctx, length) EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_IVLEN, length, NULL)
214			#define EVP_CIPHER_CTX_get_aead_tag(ctx, ptr, length) EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_GET_TAG, length, ptr)
215			#define EVP_CIPHER_CTX_set_aead_tag(ctx, ptr, length) EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_TAG, length, ptr)
216			#define EVP_CIPHER_CTX_get_name EVP_CIPHER_CTX_get0_name
217			#define EVP_CIPHER_CTX_get_cipher EVP_CIPHER_CTX_get1_cipher
218
219			#define EVP_MD_digest EVP_Digest
220			#define EVP_MD_get_name EVP_MD_get0_name
221			#define EVP_MD_get_description EVP_MD_get0_description
222			#undef EVP_MD_CTX_init
223			#define EVP_MD_CTX_get_md EVP_MD_CTX_get1_md
224			#define EVP_MD_CTX_get_name EVP_MD_CTX_get0_name
225			#define EVP_MD_CTX_init EVP_DigestInit_ex2
226			#define EVP_MD_CTX_update EVP_DigestUpdate
227			#define EVP_MD_CTX_final EVP_DigestFinal_ex
228			#define EVP_MD_CTX_final_xof EVP_DigestFinalXOF
229			#define EVP_MD_CTX_squeeze EVP_DigestSqueeze
230			#define EVP_MD_CTX_sign_init EVP_DigestSignInit
231			#define EVP_MD_CTX_sign_update EVP_DigestSignUpdate
232			#define EVP_MD_CTX_sign_final EVP_DigestSignFinal
233			#define EVP_MD_CTX_sign EVP_DigestSign
234			#define EVP_MD_CTX_verify_init EVP_DigestVerifyInit
235			#define EVP_MD_CTX_verify_update EVP_DigestVerifyUpdate
236			#define EVP_MD_CTX_verify_final EVP_DigestVerifyFinal
237			#define EVP_MD_CTX_verify EVP_DigestVerify
238
239			#define EVP_MAC_get_name EVP_MAC_get0_name
240			#define EVP_MAC_get_description EVP_MAC_get0_description
241			#define EVP_MAC_CTX_get_mac EVP_MAC_CTX_get0_mac
242			#define EVP_MAC_CTX_get_name EVP_MAC_CTX_get0_name
243
244			#define EVP_KDF_get_name EVP_KDF_get0_name
245			#define EVP_KDF_get_description EVP_KDF_get0_description
246			#define EVP_KDF_CTX_get_name EVP_KDF_CTX_get0_name
247			#define EVP_KDF_CTX_kdf(ctx) (EVP_KDF*)EVP_KDF_CTX_kdf(ctx)
248
249			#define EVP_SIGNATURE_get_name EVP_SIGNATURE_get0_name
250			#define EVP_SIGNATURE_get_description EVP_SIGNATURE_get0_description
251
252			#define EVP_PKEY_read_pem_private_key PEM_read_bio_PrivateKey_ex
253			#define EVP_PKEY_write_pem_private_key PEM_write_bio_PrivateKey_ex
254			#define EVP_PKEY_read_pem_public_key PEM_read_bio_PUBKEY_ex
255			#define EVP_PKEY_write_pem_public_key PEM_write_bio_PUBKEY_ex
256			#define EVP_PKEY_new_raw_private_key EVP_PKEY_new_raw_private_key_ex
257			#define EVP_PKEY_new_raw_public_key EVP_PKEY_new_raw_public_key_ex
258			#define EVP_PKEY_get_description EVP_PKEY_get0_description
259			#define EVP_PKEY_get_type_name EVP_PKEY_get0_type_name
260			#define EVP_PKEY_get_encoded_public_key EVP_PKEY_get1_encoded_public_key
261			#define EVP_PKEY_set_encoded_public_key EVP_PKEY_set1_encoded_public_key
262			#define EVP_PKEY_encrypt_init EVP_PKEY_encrypt_init_ex
263			#define EVP_PKEY_decrypt_init EVP_PKEY_decrypt_init_ex
264			#define EVP_PKEY_derive_init EVP_PKEY_derive_init_ex
265			#define EVP_PKEY_derive_set_peer EVP_PKEY_derive_set_peer_ex
266			#define EVP_PKEY_CTX_add_hkdf_info EVP_PKEY_CTX_add1_hkdf_info
267			#define EVP_PKEY_CTX_set_hkdf_salt EVP_PKEY_CTX_set1_hkdf_salt
268			#define EVP_PKEY_CTX_set_hkdf_key EVP_PKEY_CTX_set1_hkdf_key
269			#define EVP_PKEY_CTX_get_dh_kdf_oid EVP_PKEY_CTX_get0_dh_kdf_oid
270			#define EVP_PKEY_CTX_set_dh_kdf_oid EVP_PKEY_CTX_set0_dh_kdf_oid
271			#define EVP_PKEY_CTX_get_rsa_oaep_label EVP_PKEY_CTX_get0_rsa_oaep_label
272			#define EVP_PKEY_CTX_set_rsa_oaep_label EVP_PKEY_CTX_set0_rsa_oaep_label
273			#define EVP_PKEY_CTX_set_id EVP_PKEY_CTX_set1_id
274
275			#if !OPENSSL_VERSION_PREREQ(3, 4)
276	0		static int EVP_PKEY_sign_init_ex2(EVP_PKEY_CTX ctx, EVP_SIGNATURE algo, const OSSL_PARAM params[]) {
277	0	0	if (algo)
278	0		return FALSE;
279	0		return EVP_PKEY_sign_init_ex(ctx, params);
280			}
281
282	0		static int EVP_PKEY_verify_init_ex2(EVP_PKEY_CTX ctx, EVP_SIGNATURE algo, const OSSL_PARAM params[]) {
283	0	0	if (algo)
284	0		return FALSE;
285	0		return EVP_PKEY_verify_init_ex(ctx, params);
286			}
287			#endif
288			#define EVP_PKEY_sign_init EVP_PKEY_sign_init_ex2
289			#define EVP_PKEY_verify_init EVP_PKEY_verify_init_ex2
290
291			#define CONSTANT2(PREFIX, VALUE) newCONSTSUB(stash, #VALUE, newSVuv(PREFIX##VALUE))
292
293	12		static unsigned char* S_make_buffer(pTHX_ SV** retval, size_t size) {
294	12		*retval = newSVpv("", 0);
295	12	50	char* ptr = SvGROW(*retval, size);
		100
296	12		return (unsigned char*)ptr;
297			}
298			#define make_buffer(svp, size) S_make_buffer(aTHX_ svp, size)
299
300	1		static char* S_grow_buffer(pTHX_ SV* buffer, size_t size) {
301	1	50	SvUPGRADE(buffer, SVt_PV);
302	1	50	SV_CHECK_THINKFIRST(buffer);
303	1	50	return SvGROW(buffer, size);
		50
304			}
305			#define grow_buffer(sv, size) S_grow_buffer(aTHX_ sv, size)
306
307	13		static inline void S_set_buffer_length(pTHX_ SV* buffer, ssize_t result) {
308	13		SvCUR_set(buffer, result);
309	13		SvPOK_only(buffer);
310	13		}
311			#define set_buffer_length(buffer, result) S_set_buffer_length(aTHX_ buffer, result)
312
313	7		static OSSL_PARAM* S_params_for(pTHX_ const OSSL_PARAM* settable, SV* input) {
314	7	50	if (!SvROK(input) \|\| SvTYPE(SvRV(input)) != SVt_PVHV)
		50
315	0		return NULL;
316
317	7		OSSL_PARAM_BLD* builder = OSSL_PARAM_BLD_new();
318	7		HV* hash = (HV*)SvRV(input);
319
320	7		hv_iterinit(hash);
321			char* name;
322			I32 name_len;
323			SV* sv;
324
325	19	100	while (sv = hv_iternextsv(hash, &name, &name_len)) {
326	12		const OSSL_PARAM* found = OSSL_PARAM_locate_const(settable, name);
327
328	12	100	if (found) {
329			const BIGNUM* big;
330	11	50	if (found->data_type == OSSL_PARAM_INTEGER) {
331	0	0	if (big = get_BN(aTHX_ sv))
332	0		OSSL_PARAM_BLD_push_BN(builder, found->key, big);
333			else
334	0		OSSL_PARAM_BLD_push_int64(builder, found->key, SvIV(sv));
335	11	100	} else if (found->data_type == OSSL_PARAM_UNSIGNED_INTEGER) {
336	6	50	if (big = get_BN(aTHX_ sv))
337	0		OSSL_PARAM_BLD_push_BN(builder, found->key, big);
338			else
339	6		OSSL_PARAM_BLD_push_uint64(builder, found->key, SvUV(sv));
340	5	50	} else if (found->data_type == OSSL_PARAM_REAL) {
341	0		OSSL_PARAM_BLD_push_double(builder, found->key, SvNV(sv));
342	5	100	} else if (found->data_type == OSSL_PARAM_UTF8_STRING) {
343			STRLEN length;
344	4		const char* ptr = SvPVutf8(sv, length);
345	4		OSSL_PARAM_BLD_push_utf8_string(builder, found->key, ptr, length);
346	1	50	} else if (found->data_type == OSSL_PARAM_OCTET_STRING) {
347			STRLEN length;
348	1		const char* ptr = SvPVbyte(sv, length);
349	1		OSSL_PARAM_BLD_push_octet_string(builder, found->key, ptr, length);
350			}
351			}
352			}
353
354	7		OSSL_PARAM* result = OSSL_PARAM_BLD_to_param(builder);
355	7		OSSL_PARAM_BLD_free(builder);
356	7		SAVEDESTRUCTOR(OSSL_PARAM_free, result);
357	7		return result;
358			}
359			#define params_for(settable, sv) S_params_for(aTHX_ settable, sv)
360
361	1		static SV* S_make_param_scalar(pTHX_ OSSL_PARAM* iter) {
362	1	50	if (iter->data_type == OSSL_PARAM_INTEGER) {
363	0	0	if (iter->data_size == 0)
364	0		return newSViv(0);
365	0	0	else if (iter->data_size <= IVSIZE) {
366			int64_t value;
367	0		OSSL_PARAM_get_int64(iter, &value);
368	0		return newSViv(value);
369			} else {
370	0		BIGNUM* value = NULL;
371	0		OSSL_PARAM_get_BN(iter, &value);
372	0		return make_BN(aTHX_ value);
373			}
374			}
375	1	50	else if (iter->data_type == OSSL_PARAM_UNSIGNED_INTEGER) {
376	1	50	if (iter->data_size == 0)
377	0		return newSVuv(0);
378	1	50	else if (iter->data_size <= UVSIZE) {
379	1		uint64_t value = 0;
380	1		OSSL_PARAM_get_uint64(iter, &value);
381	1		return newSVuv(value);
382			} else {
383	0		BIGNUM* value = NULL;
384	0		OSSL_PARAM_get_BN(iter, &value);
385	0		return make_BN(aTHX_ value);
386			}
387			}
388	0	0	else if (iter->data_type == OSSL_PARAM_REAL) {
389			double value;
390	0		OSSL_PARAM_get_double(iter, &value);
391	0		return newSVnv(value);
392			}
393	0	0	else if (iter->data_type == OSSL_PARAM_UTF8_STRING) {
394	0		return newSVpvn_utf8((const char*)iter->data, iter->data_size, 1);
395			}
396	0	0	else if (iter->data_type == OSSL_PARAM_OCTET_STRING) {
397	0		return newSVpvn((const char*)iter->data, iter->data_size);
398			}
399
400	0		return NULL;
401			}
402			#define make_param_scalar(params) S_make_param_scalar(aTHX_ params)
403
404			#define GENERATE_GET_PARAM(prefix, arg, name)\
405			RETVAL = &PL_sv_undef;\
406			const OSSL_PARAM* description = OSSL_PARAM_locate_const(prefix ## _gettable_params(arg), name);\
407			if (description) {\
408			OSSL_PARAM params[] = {\
409			OSSL_PARAM_DEFN(description->key, description->data_type, NULL, SIZE_MAX),\
410			OSSL_PARAM_END,\
411			};\
412			if (prefix ## _get_params(arg, params)) {\
413			if (OSSL_PARAM_modified(params)) {\
414			params->data = OPENSSL_zalloc(params->return_size);\
415			params->data_size = params->return_size;\
416			}\
417			if (prefix ## _get_params(arg, params))\
418			RETVAL = make_param_scalar(params);\
419			}\
420			}
421
422			#ifdef MULTIPLICITY
423			#define iTHX aTHX
424			#else
425			#define iTHX NULL
426			#endif
427
428	0		static void EVP_name_callback(const char* name, void* vdata) {
429			dTHXa((PerlInterpreter*)vdata);
430	0		dSP;
431	0	0	mXPUSHp(name, strlen(name));
432	0		PUTBACK;
433	0		}
434
435			#define DEFINE_PROVIDED_CALLBACK(c_type)\
436			static void c_type ## _provided_callback(c_type* provided, void* vdata) {\
437			dTHXa((PerlInterpreter*)vdata);\
438			c_type ## _up_ref(provided);\
439			SV* object = make_ ## c_type(aTHX_ provided);\
440			dSP;\
441			mXPUSHs(object);\
442			PUTBACK;\
443			}
444	0	0	DEFINE_PROVIDED_CALLBACK(EVP_RAND)
445	124	50	DEFINE_PROVIDED_CALLBACK(EVP_CIPHER)
446	22	50	DEFINE_PROVIDED_CALLBACK(EVP_MD)
447	9	50	DEFINE_PROVIDED_CALLBACK(EVP_MAC)
448	12	50	DEFINE_PROVIDED_CALLBACK(EVP_KDF)
449	0	0	DEFINE_PROVIDED_CALLBACK(EVP_SIGNATURE)
450
451			typedef int Bool;
452			typedef int Success;
453			#define undef &PL_sv_undef
454
455			// This will force byte semantics on all strings
456			// This should come as the last thing in the C section of this file
457			#undef SvPV
458			#define SvPV(sv, len) SvPVbyte(sv, len)
459			#undef SvPV_nolen
460			#define SvPV_nolen(sv) SvPVbyte_nolen(sv)
461
462			MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3 PREFIX = OpenSSL_
463
464			REQUIRE: 3.60
465
466			PROTOTYPES: DISABLE
467
468			TYPEMAP: <
469			const unsigned char* T_PV
470			Bool T_BOOL
471			struct timeval T_TIMEVAL
472			uint64_t T_UV
473			Success T_SUCCESS
474
475			Crypt::OpenSSL3::Random T_MAGICEXT
476			Crypt::OpenSSL3::Random::Context T_MAGICEXT
477			Crypt::OpenSSL3::Cipher T_MAGICEXT
478			Crypt::OpenSSL3::Cipher::Context T_MAGICEXT
479			Crypt::OpenSSL3::MD T_MAGICEXT
480			Crypt::OpenSSL3::MD::Context T_MAGICEXT
481			Crypt::OpenSSL3::MAC T_MAGICEXT
482			Crypt::OpenSSL3::MAC::Context T_MAGICEXT
483			Crypt::OpenSSL3::KDF T_MAGICEXT
484			Crypt::OpenSSL3::KDF::Context T_MAGICEXT
485			Crypt::OpenSSL3::Signature T_MAGICEXT
486			Crypt::OpenSSL3::PKey T_MAGICEXT
487			Crypt::OpenSSL3::PKey::Context T_MAGICEXT
488
489			Crypt::OpenSSL3::BIO T_MAGICEXT
490			Crypt::OpenSSL3::BIO::Address T_MAGICEXT
491			Crypt::OpenSSL3::BIO::PollDescriptor T_MAGICBUF
492			Crypt::OpenSSL3::Error T_INTOBJ
493
494			Crypt::OpenSSL3::BigNum T_MAGICEXT
495			Crypt::OpenSSL3::BigNum::Context T_MAGICEXT
496
497			Crypt::OpenSSL3::ASN1::Object T_MAGICEXT
498			Crypt::OpenSSL3::X509 T_MAGICEXT
499			Crypt::OpenSSL3::X509::Store T_MAGICEXT
500			Crypt::OpenSSL3::X509::Name T_MAGICEXT
501			Crypt::OpenSSL3::X509::Name::Entry T_MAGICEXT
502			Crypt::OpenSSL3::X509::VerifyResult T_INTOBJ
503
504			Crypt::OpenSSL3::SSL::Method T_MAGICEXT
505			Crypt::OpenSSL3::SSL::Context T_MAGICEXT
506			Crypt::OpenSSL3::SSL T_MAGICEXT
507			Crypt::OpenSSL3::SSL::Session T_MAGICEXT
508			Crypt::OpenSSL3::SSL::Cipher T_MAGICEXT
509
510			PARAMS(EVP_RAND_CTX) T_PARAMS
511			PARAMS(EVP_CIPHER_CTX) T_PARAMS
512			CTX_PARAMS(EVP_CIPHER) T_CTX_PARAMS
513			PARAMS(EVP_MD_CTX) T_PARAMS
514			CTX_PARAMS(EVP_MD) T_CTX_PARAMS
515			PARAMS(EVP_MAC_CTX) T_PARAMS
516			PARAMS(EVP_KDF_CTX) T_PARAMS
517			PARAMS(EVP_PKEY) T_PARAMS
518			PARAMS(EVP_PKEY_CTX) T_PARAMS
519			CTX_PARAMS(EVP_SIGNATURE) T_CTX_PARAMS
520
521			INPUT
522			T_PARAMS
523			const OSSL_PARAM* settable = ${ (my $settable = $type) =~ s/ PARAMS $ (\w+) $ /$1_settable_params(ctx)/x; \$settable };
524			$var = params_for(settable, $arg);
525
526			T_CTX_PARAMS
527			const OSSL_PARAM* settable = ${ (my $settable = $type) =~ s/ CTX_PARAMS $ (\w+) $ /$1_settable_ctx_params(type)/x; \$settable };
528			$var = params_for(settable, $arg);
529
530			OUTPUT
531			T_TIMEVAL
532			sv_setnv($arg, $var.tv_sec + $var.tv_usec / 1000000.0);
533			T_SUCCESS
534			${"$var" eq "RETVAL" ? \"$arg = $var < 0 ? &PL_sv_undef : boolSV($var);" : \"sv_setsv($arg, $var < 0 ? &PL_sv_undef : boolSV($var));"}
535			T_PV
536			sv_setpv((SV)$arg, (const char)$var);
537			END
538
539			BOOT:
540			{
541	37		HV* stash = gv_stashpvs("Crypt::OpenSSL3::", GV_ADD \| GV_ADDMULTI);
542	37		CONSTANT2(OPENSSL_, VERSION_STRING);
543	37		CONSTANT2(OPENSSL_, VERSION_TEXT);
544	37		CONSTANT2(OPENSSL_, FULL_VERSION_STRING);
545	37		CONSTANT2(OPENSSL_, CFLAGS);
546	37		CONSTANT2(OPENSSL_, BUILT_ON);
547	37		CONSTANT2(OPENSSL_, PLATFORM);
548	37		CONSTANT2(OPENSSL_, DIR);
549	37		CONSTANT2(OPENSSL_, ENGINES_DIR);
550	37		CONSTANT2(OPENSSL_, MODULES_DIR);
551	37		CONSTANT2(OPENSSL_, CPU_INFO);
552	37		CONSTANT2(OPENSSL_, INFO_CONFIG_DIR);
553	37		CONSTANT2(OPENSSL_, INFO_ENGINES_DIR);
554	37		CONSTANT2(OPENSSL_, INFO_MODULES_DIR);
555	37		CONSTANT2(OPENSSL_, INFO_DSO_EXTENSION);
556	37		CONSTANT2(OPENSSL_, INFO_DIR_FILENAME_SEPARATOR);
557	37		CONSTANT2(OPENSSL_, INFO_LIST_SEPARATOR);
558	37		CONSTANT2(OPENSSL_, INFO_CPU_SETTINGS);
559			#if OPENSSL_VERSION_PREREQ(3, 4)
560			CONSTANT2(OPENSSL_, WINCTX);
561			CONSTANT2(OPENSSL_, INFO_WINDOWS_CONTEXT);
562			#endif
563			}
564
565			const char *OpenSSL_version(int t = OPENSSL_VERSION_STRING)
566
567			unsigned long OpenSSL_version_num()
568
569			MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3 PREFIX = OPENSSL_
570
571			unsigned int OPENSSL_version_major()
572
573			unsigned int OPENSSL_version_minor()
574
575			unsigned int OPENSSL_version_patch()
576
577			const char *OPENSSL_version_pre_release()
578
579			const char *OPENSSL_version_build_metadata()
580
581			const char *OPENSSL_info(int t)
582
583			MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3 PREFIX = ERR_
584
585			Crypt::OpenSSL3::Error ERR_get_error()
586
587			Crypt::OpenSSL3::Error ERR_peek_error()
588
589			void ERR_clear_error()
590
591			MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::Error PREFIX = ERR_
592
593			SV* ERR_error_string(unsigned long e, size_t length = 64)
594			CODE:
595	0		char* ptr = (char*)make_buffer(&RETVAL, length);
596	0		ERR_error_string_n(e, ptr, length);
597	0		set_buffer_length(RETVAL, strlen(ptr));
598			OUTPUT:
599			RETVAL
600
601			MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::BIO PREFIX = BIO_
602
603			Crypt::OpenSSL3::BIO BIO_new_file(SV* classname, const char filename, const char mode)
604			C_ARGS: filename, mode
605
606			Crypt::OpenSSL3::BIO BIO_new_fd(class, int fd, bool close_flag = FALSE)
607			INTERFACE: BIO_new_fd BIO_new_socket BIO_new_dgram
608			C_ARGS: fd, close_flag
609
610			NO_OUTPUT int BIO_new_bio_pair(SV* classname, OUTLIST Crypt::OpenSSL3::BIO bio1, size_t writebuf1, OUTLIST Crypt::OpenSSL3::BIO bio2, size_t writebuf2);
611			C_ARGS: &bio1, writebuf1, &bio2, writebuf2
612			POSTCALL:
613	1	50	if (!RETVAL)
614	0		XSRETURN_EMPTY;
615
616			Crypt::OpenSSL3::BIO BIO_new_mem(class)
617			C_ARGS:
618
619			bool BIO_reset(Crypt::OpenSSL3::BIO b)
620
621			int BIO_seek(Crypt::OpenSSL3::BIO b, int ofs)
622
623			int BIO_tell(Crypt::OpenSSL3::BIO b)
624
625			bool BIO_flush(Crypt::OpenSSL3::BIO b)
626
627			bool BIO_eof(Crypt::OpenSSL3::BIO b)
628
629			bool BIO_set_close(Crypt::OpenSSL3::BIO b, bool flag)
630
631			bool BIO_get_close(Crypt::OpenSSL3::BIO b)
632
633			int BIO_pending(Crypt::OpenSSL3::BIO b)
634
635			int BIO_wpending(Crypt::OpenSSL3::BIO b)
636
637			size_t BIO_ctrl_pending(Crypt::OpenSSL3::BIO b)
638
639			size_t BIO_ctrl_wpending(Crypt::OpenSSL3::BIO b)
640
641			NO_OUTPUT int BIO_read(Crypt::OpenSSL3::BIO b, OUTLIST SV* out, int size)
642			INTERFACE: BIO_read BIO_gets BIO_get_line
643			INIT:
644	0		unsigned char* ptr = make_buffer(&out, size);
645			C_ARGS: b, ptr, size
646			POSTCALL:
647	0	0	if (RETVAL >= 0)
648	0		set_buffer_length(out, RETVAL);
649
650			int BIO_write(Crypt::OpenSSL3::BIO b, const char *data, int length(data))
651
652			bool BIO_get_ktls_send(Crypt::OpenSSL3::BIO b)
653
654			bool BIO_get_ktls_recv(Crypt::OpenSSL3::BIO b)
655
656			#if OPENSSL_VERSION_PREREQ(3, 2)
657			bool BIO_get_rpoll_descriptor(Crypt::OpenSSL3::BIO b, Crypt::OpenSSL3::BIO::PollDescriptor desc)
658
659			bool BIO_get_wpoll_descriptor(Crypt::OpenSSL3::BIO b, Crypt::OpenSSL3::BIO::PollDescriptor desc)
660			#endif
661
662
663			MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::BIO::Address PREFIX = BIO_ADDR_
664
665			#if OPENSSL_VERSION_PREREQ(3, 2)
666
667			Crypt::OpenSSL3::BIO::Address BIO_ADDR_new()
668
669			bool BIO_ADDR_copy(Crypt::OpenSSL3::BIO::Address dst, Crypt::OpenSSL3::BIO::Address src)
670
671			Crypt::OpenSSL3::BIO::Address BIO_ADDR_dup(Crypt::OpenSSL3::BIO::Address ap)
672
673			void BIO_ADDR_clear(Crypt::OpenSSL3::BIO::Address ap)
674
675			bool BIO_ADDR_rawmake(Crypt::OpenSSL3::BIO::Address ap, int family, const char *where, size_t length(where), unsigned short port)
676
677			int BIO_ADDR_family(Crypt::OpenSSL3::BIO::Address ap)
678
679			SV* BIO_ADDR_rawaddress(Crypt::OpenSSL3::BIO::Address ap)
680			CODE:
681			size_t length = 0;
682			if (BIO_ADDR_rawaddress(ap, NULL, &length)) {
683			unsigned char* ptr = make_buffer(&RETVAL, length);
684			if (BIO_ADDR_rawaddress(ap, ptr, &length))
685			set_buffer_length(RETVAL, length);
686			} else
687			RETVAL = &PL_sv_undef;
688			OUTPUT:
689			RETVAL
690
691			unsigned short BIO_ADDR_rawport(Crypt::OpenSSL3::BIO::Address ap)
692
693			char *BIO_ADDR_hostname_string(Crypt::OpenSSL3::BIO::Address ap, int numeric)
694			INTERFACE:
695			BIO_ADDR_hostname_string BIO_ADDR_service_string BIO_ADDR_path_string
696			CLEANUP:
697			OPENSSL_free(RETVAL);
698
699			#endif
700
701			MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::BIO::PollDescriptor PREFIX = BIO_POLL_DESCRIPTOR_
702			BOOT:
703			{
704			#if OPENSSL_VERSION_PREREQ(3, 2)
705			HV* stash = gv_stashpvs("Crypt::OpenSSL3::BIO::PollDescriptor", GV_ADD \| GV_ADDMULTI);
706			CONSTANT2(BIO_POLL_DESCRIPTOR_, TYPE_NONE);
707			CONSTANT2(BIO_POLL_DESCRIPTOR_, TYPE_SOCK_FD);
708			CONSTANT2(BIO_POLL_DESCRIPTOR_, CUSTOM_START);
709			#endif
710			}
711
712			#if OPENSSL_VERSION_PREREQ(3, 2)
713			Crypt::OpenSSL3::BIO::PollDescriptor BIO_POLL_DESCRIPTOR_new(class)
714
715			int BIO_POLL_DESCRIPTOR_type(Crypt::OpenSSL3::BIO::PollDescriptor desc)
716
717			int BIO_POLL_DESCRIPTOR_fd(Crypt::OpenSSL3::BIO::PollDescriptor desc)
718			#endif
719
720			MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::BigNum PREFIX = BN_
721
722			BOOT:
723			{
724	37		HV* stash = gv_stashpvs("Crypt::OpenSSL3::BigNum", GV_ADD \| GV_ADDMULTI);
725	37		CONSTANT2(BN_, RAND_TOP_ANY);
726	37		CONSTANT2(BN_, RAND_TOP_ONE);
727	37		CONSTANT2(BN_, RAND_TOP_TWO);
728
729	37		CONSTANT2(BN_, RAND_BOTTOM_ANY);
730	37		CONSTANT2(BN_, RAND_BOTTOM_ODD);
731			}
732
733
734			Crypt::OpenSSL3::BigNum BN_new(SV* classname)
735			INTERFACE: BN_new BN_secure_new
736			C_ARGS:
737
738			Crypt::OpenSSL3::BigNum BN_dup(Crypt::OpenSSL3::BigNum self)
739
740			bool BN_copy(Crypt::OpenSSL3::BigNum self, Crypt::OpenSSL3::BigNum other)
741
742			void BN_clear(Crypt::OpenSSL3::BigNum a)
743
744			bool BN_add(Crypt::OpenSSL3::BigNum r, Crypt::OpenSSL3::BigNum a, Crypt::OpenSSL3::BigNum b)
745
746			bool BN_sub(Crypt::OpenSSL3::BigNum r, Crypt::OpenSSL3::BigNum a, Crypt::OpenSSL3::BigNum b)
747
748			bool BN_mul(Crypt::OpenSSL3::BigNum r, Crypt::OpenSSL3::BigNum a, Crypt::OpenSSL3::BigNum b, Crypt::OpenSSL3::BigNum::Context ctx)
749
750			bool BN_sqr(Crypt::OpenSSL3::BigNum r, Crypt::OpenSSL3::BigNum a, Crypt::OpenSSL3::BigNum::Context ctx)
751
752			bool BN_div(Crypt::OpenSSL3::BigNum dv, Crypt::OpenSSL3::BigNum rem, Crypt::OpenSSL3::BigNum a, Crypt::OpenSSL3::BigNum d, Crypt::OpenSSL3::BigNum::Context ctx)
753
754			bool BN_mod(Crypt::OpenSSL3::BigNum rem, Crypt::OpenSSL3::BigNum a, Crypt::OpenSSL3::BigNum m, Crypt::OpenSSL3::BigNum::Context ctx)
755
756			bool BN_nnmod(Crypt::OpenSSL3::BigNum r, Crypt::OpenSSL3::BigNum a, Crypt::OpenSSL3::BigNum m, Crypt::OpenSSL3::BigNum::Context ctx)
757
758			bool BN_mod_add(Crypt::OpenSSL3::BigNum r, Crypt::OpenSSL3::BigNum a, Crypt::OpenSSL3::BigNum b, Crypt::OpenSSL3::BigNum m, Crypt::OpenSSL3::BigNum::Context ctx)
759
760			bool BN_mod_sub(Crypt::OpenSSL3::BigNum r, Crypt::OpenSSL3::BigNum a, Crypt::OpenSSL3::BigNum b, Crypt::OpenSSL3::BigNum m, Crypt::OpenSSL3::BigNum::Context ctx)
761
762			bool BN_mod_mul(Crypt::OpenSSL3::BigNum r, Crypt::OpenSSL3::BigNum a, Crypt::OpenSSL3::BigNum b, Crypt::OpenSSL3::BigNum m, Crypt::OpenSSL3::BigNum::Context ctx)
763
764			bool BN_mod_sqr(Crypt::OpenSSL3::BigNum r, Crypt::OpenSSL3::BigNum a, Crypt::OpenSSL3::BigNum m, Crypt::OpenSSL3::BigNum::Context ctx)
765
766			bool BN_mod_sqrt(Crypt::OpenSSL3::BigNum in, Crypt::OpenSSL3::BigNum a, Crypt::OpenSSL3::BigNum p, Crypt::OpenSSL3::BigNum::Context ctx)
767
768			bool BN_exp(Crypt::OpenSSL3::BigNum r, Crypt::OpenSSL3::BigNum a, Crypt::OpenSSL3::BigNum p, Crypt::OpenSSL3::BigNum::Context ctx)
769
770			bool BN_mod_exp(Crypt::OpenSSL3::BigNum r, Crypt::OpenSSL3::BigNum a, Crypt::OpenSSL3::BigNum p, Crypt::OpenSSL3::BigNum m, Crypt::OpenSSL3::BigNum::Context ctx)
771
772			bool BN_gcd(Crypt::OpenSSL3::BigNum r, Crypt::OpenSSL3::BigNum a, Crypt::OpenSSL3::BigNum b, Crypt::OpenSSL3::BigNum::Context ctx)
773
774			int BN_num_bytes(Crypt::OpenSSL3::BigNum a)
775
776			int BN_num_bits(Crypt::OpenSSL3::BigNum a)
777
778			NO_OUTPUT int BN_bn2bin(Crypt::OpenSSL3::BigNum a, OUTLIST SV* out)
779			INIT:
780	0		unsigned char* ptr = make_buffer(&out, BN_num_bytes(a));
781			C_ARGS: a, ptr
782			POSTCALL:
783	0		set_buffer_length(out, RETVAL);
784
785			NO_OUTPUT int BN_bn2binpad(Crypt::OpenSSL3::BigNum a, OUTLIST SV* out, int tolen = BN_num_bytes(a))
786			INTERFACE: BN_bn2binpad BN_bn2lebinpad BN_bn2nativepad
787			INIT:
788	0		unsigned char* ptr = make_buffer(&out, tolen);
789			C_ARGS: a, ptr, tolen
790			POSTCALL:
791	0	0	if (RETVAL >= 0)
792	0		set_buffer_length(out, RETVAL);
793
794			Crypt::OpenSSL3::BigNum BN_bin2bn(const unsigned char *s, int length(s))
795			C_ARGS: s, XSauto_length_of_s, NULL
796
797
798			NO_OUTPUT int BN_bn2lebinpad(Crypt::OpenSSL3::BigNum a, OUTLIST SV* out, int tolen)
799			INIT:
800	0		unsigned char* ptr = make_buffer(&out, tolen);
801			C_ARGS: a, ptr, tolen
802			POSTCALL:
803	0	0	if (RETVAL >= 0)
804	0		set_buffer_length(out, RETVAL);
805
806			Crypt::OpenSSL3::BigNum BN_lebin2bn(const unsigned char *s, int length(s))
807			C_ARGS: s, XSauto_length_of_s, NULL
808
809
810			NO_OUTPUT int BN_bn2nativepad(Crypt::OpenSSL3::BigNum a, OUTLIST SV* out, int tolen)
811			INIT:
812	0		unsigned char* ptr = make_buffer(&out, tolen);
813			C_ARGS: a, ptr, tolen
814			POSTCALL:
815	0	0	if (RETVAL >= 0)
816	0		set_buffer_length(out, RETVAL);
817
818			Crypt::OpenSSL3::BigNum BN_native2bn(const unsigned char *s, int length(s))
819			C_ARGS: s, XSauto_length_of_s, NULL
820
821			#if OPENSSL_VERSION_PREREQ(3, 2)
822			NO_OUTPUT int BN_signed_bn2lebin(Crypt::OpenSSL3::BigNum a, OUTLIST SV* out, int tolen = BN_num_bytes(a))
823			INTERFACE: BN_signed_bn2bin BN_signed_bn2lebin BN_signed_bn2native
824			INIT:
825			unsigned char* ptr = make_buffer(&out, tolen);
826			C_ARGS: a, ptr, tolen
827			POSTCALL:
828			if (RETVAL >= 0)
829			set_buffer_length(out, RETVAL);
830
831			Crypt::OpenSSL3::BigNum BN_signed_bin2bn(const unsigned char *s, int length(s))
832			C_ARGS: s, XSauto_length_of_s, NULL
833
834			Crypt::OpenSSL3::BigNum BN_signed_lebin2bn(const unsigned char *s, int length(s))
835			C_ARGS: s, XSauto_length_of_s, NULL
836
837
838			NO_OUTPUT int BN_signed_bn2native(Crypt::OpenSSL3::BigNum a, OUTLIST SV* out, int tolen)
839			INIT:
840			unsigned char* ptr = make_buffer(&out, tolen);
841			C_ARGS: a, ptr, tolen
842			POSTCALL:
843			if (RETVAL >= 0)
844			set_buffer_length(out, RETVAL);
845
846			Crypt::OpenSSL3::BigNum BN_signed_native2bn(const unsigned char *s, int length(s))
847			C_ARGS: s, XSauto_length_of_s, NULL
848			#endif
849
850			char *BN_bn2hex(Crypt::OpenSSL3::BigNum a)
851			INTERFACE: BN_bn2hex BN_bn2dec
852			CLEANUP:
853	0		OPENSSL_free(RETVAL);
854
855			int BN_hex2bn(Crypt::OpenSSL3::BigNum a, const char *str)
856			INTERFACE: BN_hex2bn BN_dec2bn
857			C_ARGS: &a, str
858
859			bool BN_print(Crypt::OpenSSL3::BIO fp, Crypt::OpenSSL3::BigNum a)
860
861
862			NO_OUTPUT int BN_bn2mpi(Crypt::OpenSSL3::BigNum a, OUTLIST SV* out)
863			INIT:
864	0		unsigned char* ptr = make_buffer(&out, BN_bn2mpi(a, NULL));
865			C_ARGS: a, ptr
866			POSTCALL:
867	0		set_buffer_length(out, RETVAL);
868
869			Crypt::OpenSSL3::BigNum BN_mpi2bn(unsigned char *s, int len)
870			C_ARGS: s, len, NULL
871
872			bool BN_check_prime(Crypt::OpenSSL3::BigNum p, Crypt::OpenSSL3::BigNum::Context ctx)
873			C_ARGS: p, ctx, NULL
874
875			bool BN_generate_prime(Crypt::OpenSSL3::BigNum ret, int bits, int safe, Crypt::OpenSSL3::BigNum add, Crypt::OpenSSL3::BigNum rem, Crypt::OpenSSL3::BigNum::Context ctx)
876			C_ARGS: ret, bits, safe, add, rem, NULL, ctx
877
878			bool BN_set_word(Crypt::OpenSSL3::BigNum a, UV w)
879
880			UV BN_get_word(Crypt::OpenSSL3::BigNum a)
881
882			bool BN_add_word(Crypt::OpenSSL3::BigNum a, UV w)
883
884			bool BN_sub_word(Crypt::OpenSSL3::BigNum a, UV w)
885
886			bool BN_mul_word(Crypt::OpenSSL3::BigNum a, UV w)
887
888			UV BN_div_word(Crypt::OpenSSL3::BigNum a, UV w)
889
890			UV BN_mod_word(Crypt::OpenSSL3::BigNum a, UV w)
891
892			int BN_cmp(Crypt::OpenSSL3::BigNum a, Crypt::OpenSSL3::BigNum b)
893
894			int BN_ucmp(Crypt::OpenSSL3::BigNum a, Crypt::OpenSSL3::BigNum b)
895
896			bool BN_is_zero(Crypt::OpenSSL3::BigNum a)
897
898			bool BN_is_one(Crypt::OpenSSL3::BigNum a)
899
900			bool BN_is_word(Crypt::OpenSSL3::BigNum a, UV w)
901
902			bool BN_abs_is_word(Crypt::OpenSSL3::BigNum a, UV w)
903
904			bool BN_is_odd(Crypt::OpenSSL3::BigNum a)
905
906			#if OPENSSL_VERSION_PREREQ(3, 2)
907			bool BN_are_coprime(Crypt::OpenSSL3::BigNum a, Crypt::OpenSSL3::BigNum b, Crypt::OpenSSL3::BigNum::Context ctx);
908			#endif
909
910			bool BN_clear_bit(Crypt::OpenSSL3::BigNum a, int n)
911
912			bool BN_is_bit_set(Crypt::OpenSSL3::BigNum a, int n)
913
914			bool BN_mask_bits(Crypt::OpenSSL3::BigNum a, int n)
915
916			bool BN_lshift(Crypt::OpenSSL3::BigNum r, Crypt::OpenSSL3::BigNum a, int n)
917
918			bool BN_lshift1(Crypt::OpenSSL3::BigNum r, Crypt::OpenSSL3::BigNum a)
919
920			bool BN_rshift(Crypt::OpenSSL3::BigNum r, Crypt::OpenSSL3::BigNum a, int n)
921
922			bool BN_rshift1(Crypt::OpenSSL3::BigNum r, Crypt::OpenSSL3::BigNum a)
923
924			bool BN_rand_ex(Crypt::OpenSSL3::BigNum rnd, int bits, int top, int bottom, unsigned int strength, Crypt::OpenSSL3::BigNum::Context ctx)
925
926			bool BN_rand(Crypt::OpenSSL3::BigNum rnd, int bits, int top, int bottom)
927
928
929			MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::BigNum::Context PREFIX = BN_CTX_
930
931			Crypt::OpenSSL3::BigNum::Context BN_CTX_new(SV* classname)
932			INTERFACE: BN_CTX_new BN_CTX_secure_new
933			C_ARGS:
934
935			MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::X509 PREFIX = X509_
936
937			Crypt::OpenSSL3::X509 X509_dup(Crypt::OpenSSL3::X509 self)
938
939			Crypt::OpenSSL3::X509 X509_read_pem(class, Crypt::OpenSSL3::BIO bio)
940			C_ARGS: bio, NULL, NULL, NULL
941			POSTCALL:
942	0	0	if (!RETVAL)
943	0		XSRETURN_UNDEF;
944
945			bool X509_write_pem(Crypt::OpenSSL3::X509 x, Crypt::OpenSSL3::BIO bio)
946			C_ARGS: bio, x
947
948			Crypt::OpenSSL3::X509::Name X509_get_subject_name(Crypt::OpenSSL3::X509 x)
949			INTERFACE:
950			X509_get_subject_name X509_get_issuer_name
951			POSTCALL:
952	0		RETVAL = X509_NAME_dup(RETVAL);
953
954			bool X509_set_subject_name(Crypt::OpenSSL3::X509 x, Crypt::OpenSSL3::X509::Name name)
955
956			bool X509_set_issuer_name(Crypt::OpenSSL3::X509 x, Crypt::OpenSSL3::X509::Name name)
957
958			NO_OUTPUT Bool X509_digest(Crypt::OpenSSL3::X509 data, Crypt::OpenSSL3::MD type, OUTLIST SV* digest)
959			INTERFACE: X509_digest X509_pubkey_digest
960			INIT:
961	0		unsigned int output_length = EVP_MD_size(type);
962	0		unsigned char* ptr = make_buffer(&digest, output_length);
963			C_ARGS: data, type, ptr, &output_length
964			POSTCALL:
965	0	0	if (RETVAL)
966	0		set_buffer_length(digest, output_length);
967
968
969			MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::X509::VerifyResult PREFIX = X509_verify_cert_
970
971			IV X509_verify_cert_error_code(Crypt::OpenSSL3::X509::VerifyResult result)
972
973			bool X509_verify_cert_ok(Crypt::OpenSSL3::X509::VerifyResult result)
974
975			const char* X509_verify_cert_error_string(Crypt::OpenSSL3::X509::VerifyResult result)
976
977			MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::X509::Name PREFIX = X509_NAME_
978
979			Crypt::OpenSSL3::X509::Name X509_NAME_dup(Crypt::OpenSSL3::X509::Name self)
980
981			int X509_NAME_cmp(Crypt::OpenSSL3::X509::Name a, Crypt::OpenSSL3::X509::Name b)
982
983			int X509_NAME_get_index_by_NID(Crypt::OpenSSL3::X509::Name name, int nid, int lastpos)
984
985			int X509_NAME_entry_count(Crypt::OpenSSL3::X509::Name name)
986
987			Crypt::OpenSSL3::X509::Name::Entry X509_NAME_get_entry(Crypt::OpenSSL3::X509::Name name, int loc)
988			POSTCALL:
989	0		RETVAL = X509_NAME_ENTRY_dup(RETVAL);
990
991			char* X509_NAME_oneline(Crypt::OpenSSL3::X509::Name a)
992			C_ARGS: a, NULL, 0
993			CLEANUP:
994	0	0	if (RETVAL)
995	0		OPENSSL_free(RETVAL);
996
997			MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::X509::Name::Entry PREFIX = X509_NAME_ENTRY
998
999
1000
1001			MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::X509::Store PREFIX = X509_STORE_
1002
1003			bool X509_STORE_add_cert(Crypt::OpenSSL3::X509::Store store, Crypt::OpenSSL3::X509 x)
1004
1005			bool X509_STORE_set_depth(Crypt::OpenSSL3::X509::Store store, int depth)
1006
1007			bool X509_STORE_set_flags(Crypt::OpenSSL3::X509::Store store, unsigned long flags)
1008
1009			bool X509_STORE_set_purpose(Crypt::OpenSSL3::X509::Store store, int purpose)
1010
1011			bool X509_STORE_set_trust(Crypt::OpenSSL3::X509::Store store, int trust)
1012
1013			bool X509_STORE_load_locations(Crypt::OpenSSL3::X509::Store store, const char file, const char dir)
1014
1015			bool X509_STORE_set_default_paths(Crypt::OpenSSL3::X509::Store store)
1016
1017
1018			MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::SSL::Method PREFIX = SSL_Method_
1019
1020			Crypt::OpenSSL3::SSL::Method SSL_Method_TLS()
1021
1022			Crypt::OpenSSL3::SSL::Method SSL_Method_TLS_server()
1023
1024			Crypt::OpenSSL3::SSL::Method SSL_Method_TLS_client()
1025
1026			Crypt::OpenSSL3::SSL::Method SSL_Method_DTLS()
1027
1028			Crypt::OpenSSL3::SSL::Method SSL_Method_DTLS_server()
1029
1030			Crypt::OpenSSL3::SSL::Method SSL_Method_DTLS_client()
1031
1032			#if OPENSSL_VERSION_PREREQ(3, 2)
1033			Crypt::OpenSSL3::SSL::Method SSL_Method_QUIC_client()
1034
1035			Crypt::OpenSSL3::SSL::Method SSL_Method_QUIC_client_thread()
1036			#endif
1037
1038			#if OPENSSL_VERSION_PREREQ(3, 5)
1039			Crypt::OpenSSL3::SSL::Method SSL_Method_QUIC_server()
1040			#endif
1041
1042			MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::SSL::Context PREFIX = SSL_CTX_
1043
1044			Crypt::OpenSSL3::SSL::Context SSL_CTX_new(SV* classname, Crypt::OpenSSL3::SSL::Method method = TLS_method())
1045			C_ARGS: method
1046
1047			long SSL_CTX_set_options(Crypt::OpenSSL3::SSL::Context ctx, long options)
1048
1049			long SSL_CTX_clear_options(Crypt::OpenSSL3::SSL::Context ctx, long options)
1050
1051			long SSL_CTX_get_options(Crypt::OpenSSL3::SSL::Context ctx)
1052
1053			void SSL_CTX_set_read_ahead(Crypt::OpenSSL3::SSL::Context ctx, bool yes)
1054
1055			bool SSL_CTX_get_read_ahead(Crypt::OpenSSL3::SSL::Context ctx)
1056
1057			bool SSL_CTX_set_session_id_context(Crypt::OpenSSL3::SSL::Context ctx, const unsigned char *sid_ctx, unsigned int length(sid_ctx))
1058
1059			long SSL_CTX_set_mode(Crypt::OpenSSL3::SSL::Context ctx, long mode)
1060
1061			long SSL_CTX_clear_mode(Crypt::OpenSSL3::SSL::Context ctx, long mode)
1062
1063			long SSL_CTX_get_mode(Crypt::OpenSSL3::SSL::Context ctx)
1064
1065			bool SSL_CTX_set_min_proto_version(Crypt::OpenSSL3::SSL::Context ctx, int version)
1066
1067			bool SSL_CTX_set_max_proto_version(Crypt::OpenSSL3::SSL::Context ctx, int version)
1068
1069			int SSL_CTX_get_min_proto_version(Crypt::OpenSSL3::SSL::Context ctx)
1070
1071			int SSL_CTX_get_max_proto_version(Crypt::OpenSSL3::SSL::Context ctx)
1072
1073			bool SSL_CTX_set_alpn_protos(Crypt::OpenSSL3::SSL::Context ctx, const unsigned char *protos, unsigned int length(protos))
1074
1075			Crypt::OpenSSL3::X509::Store SSL_CTX_get_cert_store(Crypt::OpenSSL3::SSL::Context ctx)
1076			POSTCALL:
1077	0		X509_STORE_up_ref(RETVAL);
1078
1079			void SSL_CTX_set_cert_store(Crypt::OpenSSL3::SSL::Context ctx, Crypt::OpenSSL3::X509::Store store)
1080			POSTCALL:
1081	0		X509_STORE_up_ref(store);
1082
1083			bool SSL_CTX_load_verify_locations(Crypt::OpenSSL3::SSL::Context ctx, const char CAfile, const char CApath)
1084
1085			bool SSL_CTX_load_verify_file(Crypt::OpenSSL3::SSL::Context ctx, const char *CAfile)
1086
1087			bool SSL_CTX_load_verify_dir(Crypt::OpenSSL3::SSL::Context ctx, const char *CApath)
1088
1089			bool SSL_CTX_load_verify_store(Crypt::OpenSSL3::SSL::Context ctx, const char *CAstore)
1090
1091			bool SSL_CTX_set_default_verify_paths(Crypt::OpenSSL3::SSL::Context ctx)
1092
1093			bool SSL_CTX_set_default_verify_dir(Crypt::OpenSSL3::SSL::Context ctx)
1094
1095			bool SSL_CTX_set_default_verify_file(Crypt::OpenSSL3::SSL::Context ctx)
1096
1097			bool SSL_CTX_use_certificate(Crypt::OpenSSL3::SSL::Context ctx, Crypt::OpenSSL3::X509 x)
1098
1099			bool SSL_CTX_use_certificate_ASN1(Crypt::OpenSSL3::SSL::Context ctx, int length(d), const unsigned char *d)
1100
1101			bool SSL_CTX_use_certificate_file(Crypt::OpenSSL3::SSL::Context ctx, const char *file, int type)
1102
1103			bool SSL_CTX_use_certificate_chain_file(Crypt::OpenSSL3::SSL::Context ctx, const char *file)
1104
1105			long SSL_CTX_add_extra_chain_cert(Crypt::OpenSSL3::SSL::Context ctx, Crypt::OpenSSL3::X509 x509)
1106
1107			long SSL_CTX_clear_extra_chain_certs(Crypt::OpenSSL3::SSL::Context ctx)
1108
1109			bool SSL_CTX_use_PrivateKey(Crypt::OpenSSL3::SSL::Context ctx, Crypt::OpenSSL3::PKey pkey)
1110
1111			bool SSL_CTX_use_PrivateKey_ASN1(Crypt::OpenSSL3::SSL::Context ctx, int pk, const unsigned char *d, long length(d))
1112			C_ARGS: pk, ctx, d, XSauto_length_of_d
1113
1114			bool SSL_CTX_use_PrivateKey_file(Crypt::OpenSSL3::SSL::Context ctx, const char *file, int type)
1115
1116			bool SSL_CTX_check_private_key(Crypt::OpenSSL3::SSL::Context ctx)
1117
1118			void SSL_CTX_set_verify(Crypt::OpenSSL3::SSL::Context ctx, int mode)
1119			C_ARGS: ctx, mode, NULL
1120
1121			void SSL_CTX_set_verify_depth(Crypt::OpenSSL3::SSL::Context ctx, int depth)
1122
1123			void SSL_CTX_set_post_handshake_auth(Crypt::OpenSSL3::SSL::Context ctx, int val)
1124
1125			bool SSL_CTX_set_cipher_list(Crypt::OpenSSL3::SSL::Context ctx, const char *str)
1126
1127			bool SSL_CTX_set_ciphersuites(Crypt::OpenSSL3::SSL::Context ctx, const char *str)
1128
1129			int SSL_CTX_add_client_CA(Crypt::OpenSSL3::SSL::Context ctx, Crypt::OpenSSL3::X509 cacert)
1130			POSTCALL:
1131	0		X509_up_ref(cacert);
1132
1133			bool SSL_CTX_add_session(Crypt::OpenSSL3::SSL::Context ctx, Crypt::OpenSSL3::SSL::Session c);
1134
1135			bool SSL_CTX_remove_session(Crypt::OpenSSL3::SSL::Context ctx, Crypt::OpenSSL3::SSL::Session c);
1136
1137			long SSL_CTX_sess_number(Crypt::OpenSSL3::SSL::Context ctx)
1138
1139			long SSL_CTX_sess_connect(Crypt::OpenSSL3::SSL::Context ctx)
1140
1141			long SSL_CTX_sess_connect_good(Crypt::OpenSSL3::SSL::Context ctx)
1142
1143			long SSL_CTX_sess_connect_renegotiate(Crypt::OpenSSL3::SSL::Context ctx)
1144
1145			long SSL_CTX_sess_accept(Crypt::OpenSSL3::SSL::Context ctx)
1146
1147			long SSL_CTX_sess_accept_good(Crypt::OpenSSL3::SSL::Context ctx)
1148
1149			long SSL_CTX_sess_accept_renegotiate(Crypt::OpenSSL3::SSL::Context ctx)
1150
1151			long SSL_CTX_sess_hits(Crypt::OpenSSL3::SSL::Context ctx)
1152
1153			long SSL_CTX_sess_cb_hits(Crypt::OpenSSL3::SSL::Context ctx)
1154
1155			long SSL_CTX_sess_misses(Crypt::OpenSSL3::SSL::Context ctx)
1156
1157			long SSL_CTX_sess_timeouts(Crypt::OpenSSL3::SSL::Context ctx)
1158
1159			long SSL_CTX_sess_cache_full(Crypt::OpenSSL3::SSL::Context ctx)
1160
1161			long SSL_CTX_sess_set_cache_size(Crypt::OpenSSL3::SSL::Context ctx, long t)
1162
1163			long SSL_CTX_sess_get_cache_size(Crypt::OpenSSL3::SSL::Context ctx)
1164
1165			int SSL_CTX_set_num_tickets(Crypt::OpenSSL3::SSL::Context ctx, size_t num_tickets)
1166
1167			size_t SSL_CTX_get_num_tickets(Crypt::OpenSSL3::SSL::Context ctx)
1168
1169			#if OPENSSL_VERSION_PREREQ(3, 5)
1170
1171			bool SSL_CTX_set_domain_flags(Crypt::OpenSSL3::SSL::Context ctx, uint64_t flags)
1172
1173			NO_OUTPUT bool SSL_CTX_get_domain_flags(Crypt::OpenSSL3::SSL::Context ctx, OUTLIST uint64_t flags)
1174			POSTCALL:
1175			if (!RETVAL)
1176			XSRETURN_UNDEF;
1177			#endif
1178
1179			MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::SSL PREFIX = SSL_
1180
1181			BOOT:
1182			{
1183	37		HV* stash = gv_stashpvs("Crypt::OpenSSL3::SSL", GV_ADD \| GV_ADDMULTI);
1184	37		CONSTANT2(SSL_, ERROR_NONE);
1185	37		CONSTANT2(SSL_, ERROR_ZERO_RETURN);
1186	37		CONSTANT2(SSL_, ERROR_WANT_READ);
1187	37		CONSTANT2(SSL_, ERROR_WANT_WRITE);
1188	37		CONSTANT2(SSL_, ERROR_WANT_CONNECT);
1189	37		CONSTANT2(SSL_, ERROR_WANT_ACCEPT);
1190	37		CONSTANT2(SSL_, ERROR_WANT_X509_LOOKUP);
1191	37		CONSTANT2(SSL_, ERROR_WANT_ASYNC);
1192	37		CONSTANT2(SSL_, ERROR_WANT_ASYNC_JOB);
1193	37		CONSTANT2(SSL_, ERROR_SYSCALL);
1194	37		CONSTANT2(SSL_, ERROR_SSL);
1195
1196	37		CONSTANT2(SSL_, VERIFY_NONE);
1197	37		CONSTANT2(SSL_, VERIFY_PEER);
1198	37		CONSTANT2(SSL_, VERIFY_FAIL_IF_NO_PEER_CERT);
1199	37		CONSTANT2(SSL_, VERIFY_CLIENT_ONCE);
1200	37		CONSTANT2(SSL_, VERIFY_POST_HANDSHAKE);
1201
1202	37		CONSTANT2(SSL_, MODE_ENABLE_PARTIAL_WRITE);
1203	37		CONSTANT2(SSL_, MODE_ACCEPT_MOVING_WRITE_BUFFER);
1204	37		CONSTANT2(SSL_, MODE_AUTO_RETRY);
1205	37		CONSTANT2(SSL_, MODE_RELEASE_BUFFERS);
1206	37		CONSTANT2(SSL_, MODE_SEND_FALLBACK_SCSV);
1207	37		CONSTANT2(SSL_, MODE_ASYNC);
1208
1209	37		CONSTANT2(SSL_, FILETYPE_PEM);
1210	37		CONSTANT2(SSL_, FILETYPE_ASN1);
1211
1212	37		CONSTANT2(, TLS1_VERSION);
1213	37		CONSTANT2(, TLS1_1_VERSION);
1214	37		CONSTANT2(, TLS1_2_VERSION);
1215	37		CONSTANT2(, TLS1_3_VERSION);
1216	37		CONSTANT2(, DTLS1_VERSION);
1217	37		CONSTANT2(, DTLS1_2_VERSION);
1218			#if OPENSSL_VERSION_PREREQ(3, 2)
1219			CONSTANT2(OSSL_, QUIC1_VERSION);
1220			CONSTANT2(SSL_, ACCEPT_STREAM_NO_BLOCK);
1221			CONSTANT2(SSL_, INCOMING_STREAM_POLICY_AUTO);
1222			CONSTANT2(SSL_, INCOMING_STREAM_POLICY_ACCEPT);
1223			CONSTANT2(SSL_, INCOMING_STREAM_POLICY_REJECT);
1224			CONSTANT2(SSL_, STREAM_FLAG_UNI);
1225			CONSTANT2(SSL_, STREAM_FLAG_NO_BLOCK);
1226			CONSTANT2(SSL_, STREAM_FLAG_ADVANCE);
1227			CONSTANT2(SSL_, STREAM_TYPE_NONE);
1228			CONSTANT2(SSL_, STREAM_TYPE_BIDI);
1229			CONSTANT2(SSL_, STREAM_TYPE_READ);
1230			CONSTANT2(SSL_, STREAM_TYPE_WRITE);
1231			#endif
1232			#if OPENSSL_VERSION_PREREQ(3, 5)
1233			CONSTANT2(SSL_, ACCEPT_CONNECTION_NO_BLOCK);
1234			CONSTANT2(SSL_, DOMAIN_FLAG_SINGLE_THREAD);
1235			CONSTANT2(SSL_, DOMAIN_FLAG_MULTI_THREAD);
1236			CONSTANT2(SSL_, DOMAIN_FLAG_THREAD_ASSISTED);
1237			CONSTANT2(SSL_, DOMAIN_FLAG_BLOCKING);
1238			CONSTANT2(SSL_, DOMAIN_FLAG_LEGACY_BLOCKING);
1239			#endif
1240			}
1241
1242			Crypt::OpenSSL3::SSL SSL_new(SV* classname, Crypt::OpenSSL3::SSL::Context context)
1243			C_ARGS: context
1244
1245			Crypt::OpenSSL3::SSL::Method SSL_get_ssl_method(Crypt::OpenSSL3::SSL ssl)
1246
1247			Crypt::OpenSSL3::SSL::Context SSL_get_context(Crypt::OpenSSL3::SSL ssl)
1248			POSTCALL:
1249	0		SSL_CTX_up_ref(RETVAL);
1250
1251			NO_OUTPUT int SSL_get_event_timeout(Crypt::OpenSSL3::SSL s, OUTLIST struct timeval tv, OUTLIST Bool is_infinite)
1252			INIT:
1253	0		is_infinite = 0;
1254			POSTCALL:
1255	0	0	if (!RETVAL)
1256	0		XSRETURN_EMPTY;
1257
1258			bool SSL_handle_events(Crypt::OpenSSL3::SSL ssl)
1259
1260			long SSL_set_options(Crypt::OpenSSL3::SSL ssl, long options)
1261
1262			long SSL_clear_options(Crypt::OpenSSL3::SSL ssl, long options)
1263
1264			long SSL_get_options(Crypt::OpenSSL3::SSL ssl)
1265
1266			bool SSL_set_session_id_context(Crypt::OpenSSL3::SSL ssl, const unsigned char *sid_ctx, unsigned int length(sid_ctx))
1267
1268			long SSL_set_mode(Crypt::OpenSSL3::SSL ssl, long mode)
1269
1270			long SSL_clear_mode(Crypt::OpenSSL3::SSL ssl, long mode)
1271
1272			long SSL_get_mode(Crypt::OpenSSL3::SSL ssl)
1273
1274			bool SSL_set_min_proto_version(Crypt::OpenSSL3::SSL ssl, int version)
1275
1276			bool SSL_set_max_proto_version(Crypt::OpenSSL3::SSL ssl, int version)
1277
1278			void SSL_set_security_level(Crypt::OpenSSL3::SSL s, int level)
1279
1280			int SSL_get_security_level(Crypt::OpenSSL3::SSL s)
1281
1282			bool SSL_set_alpn_protos(Crypt::OpenSSL3::SSL ssl, const unsigned char *protos, unsigned int length(protos))
1283
1284			bool SSL_use_certificate(Crypt::OpenSSL3::SSL ssl, Crypt::OpenSSL3::X509 x)
1285
1286			bool SSL_use_certificate_ASN1(Crypt::OpenSSL3::SSL ssl, const unsigned char *d, int length(d))
1287
1288			bool SSL_use_certificate_file(Crypt::OpenSSL3::SSL ssl, const char *file, int type)
1289
1290			bool SSL_use_certificate_chain_file(Crypt::OpenSSL3::SSL ssl, const char *file)
1291
1292			bool SSL_use_PrivateKey(Crypt::OpenSSL3::SSL ssl, Crypt::OpenSSL3::PKey pkey)
1293
1294			bool SSL_use_PrivateKey_ASN1(Crypt::OpenSSL3::SSL ssl, int pk, const unsigned char *d, long length(d))
1295			C_ARGS: pk, ssl, d, XSauto_length_of_d
1296
1297			bool SSL_use_PrivateKey_file(Crypt::OpenSSL3::SSL ssl, const char *file, int type)
1298
1299			bool SSL_check_private_key(Crypt::OpenSSL3::SSL ssl)
1300
1301			void SSL_set_verify(Crypt::OpenSSL3::SSL ssl, int mode)
1302			C_ARGS: ssl, mode, NULL
1303
1304			void SSL_set_verify_depth(Crypt::OpenSSL3::SSL ssl, int depth)
1305
1306			Crypt::OpenSSL3::X509::VerifyResult SSL_get_verify_result(Crypt::OpenSSL3::SSL ssl);
1307
1308			void SSL_set_post_handshake_auth(Crypt::OpenSSL3::SSL ssl, int val)
1309
1310			bool SSL_set_cipher_list(Crypt::OpenSSL3::SSL ssl, const char *str)
1311
1312			bool SSL_set_ciphersuites(Crypt::OpenSSL3::SSL ssl, const char *str)
1313
1314			const char *SSL_get_cipher_list(Crypt::OpenSSL3::SSL ssl, int priority)
1315			POSTCALL:
1316	0	0	if (!RETVAL)
1317	0		XSRETURN_UNDEF;
1318
1319			int SSL_add_client_CA(Crypt::OpenSSL3::SSL ssl, Crypt::OpenSSL3::X509 cacert)
1320			POSTCALL:
1321	0		X509_up_ref(cacert);
1322
1323			bool SSL_verify_client_post_handshake(Crypt::OpenSSL3::SSL ssl)
1324
1325			int SSL_get_error(Crypt::OpenSSL3::SSL ssl, int ret)
1326
1327			bool SSL_set_tlsext_host_name(Crypt::OpenSSL3::SSL s, const char *name)
1328
1329			const char* SSL_get_servername(Crypt::OpenSSL3::SSL s, int type)
1330
1331			int SSL_get_servername_type(Crypt::OpenSSL3::SSL s)
1332
1333			bool SSL_set_host(Crypt::OpenSSL3::SSL s, const char *hostname)
1334
1335			int SSL_connect(Crypt::OpenSSL3::SSL ssl)
1336
1337			int SSL_accept(Crypt::OpenSSL3::SSL ssl)
1338
1339			int SSL_clear(Crypt::OpenSSL3::SSL ssl)
1340
1341			int SSL_do_handshake(Crypt::OpenSSL3::SSL ssl)
1342
1343			void SSL_set_connect_state(Crypt::OpenSSL3::SSL ssl)
1344
1345			void SSL_set_accept_state(Crypt::OpenSSL3::SSL ssl)
1346
1347			bool SSL_is_server(Crypt::OpenSSL3::SSL ssl)
1348
1349			int SSL_read(Crypt::OpenSSL3::SSL ssl, SV* buffer, size_t size)
1350			INTERFACE: SSL_read SSL_peek
1351			INIT:
1352	1		char* ptr = grow_buffer(buffer, size);
1353			C_ARGS: ssl, ptr, size
1354			POSTCALL:
1355	1	50	if (RETVAL > 0)
1356	1		set_buffer_length(buffer, RETVAL);
1357
1358			int SSL_write(Crypt::OpenSSL3::SSL ssl, const char* buf, int length(buf))
1359
1360			ssize_t SSL_sendfile(Crypt::OpenSSL3::SSL s, int fd, uint64_t offset, size_t size, int flags)
1361
1362			int SSL_shutdown(Crypt::OpenSSL3::SSL ssl)
1363
1364			bool SSL_set_fd(Crypt::OpenSSL3::SSL ssl, int fd)
1365
1366			bool SSL_set_rfd(Crypt::OpenSSL3::SSL ssl, int fd)
1367
1368			bool SSL_set_wfd(Crypt::OpenSSL3::SSL ssl, int fd)
1369
1370			int SSL_get_fd(Crypt::OpenSSL3::SSL ssl)
1371
1372			int SSL_get_rfd(Crypt::OpenSSL3::SSL ssl)
1373
1374			int SSL_get_wfd(Crypt::OpenSSL3::SSL ssl)
1375
1376			void SSL_set_rbio(Crypt::OpenSSL3::SSL s, Crypt::OpenSSL3::BIO bio)
1377			INTERFACE: SSL_set_rbio SSL_set_wbio
1378			INIT:
1379	4		BIO_up_ref(bio);
1380
1381			Crypt::OpenSSL3::BIO SSL_get_rbio(Crypt::OpenSSL3::SSL ssl)
1382			INTERFACE: SSL_get_rbio SSL_get_wbio
1383			POSTCALL:
1384	0	0	if (RETVAL)
1385	0		BIO_up_ref(RETVAL);
1386			else
1387	0		XSRETURN_UNDEF;
1388
1389			void SSL_set_read_ahead(Crypt::OpenSSL3::SSL s, bool yes)
1390
1391			bool SSL_get_read_ahead(Crypt::OpenSSL3::SSL s)
1392
1393			Crypt::OpenSSL3::SSL::Session SSL_get_session(Crypt::OpenSSL3::SSL ssl)
1394			POSTCALL:
1395	0	0	if (RETVAL)
1396	0		SSL_SESSION_up_ref(RETVAL);
1397			else
1398	0		XSRETURN_UNDEF;
1399
1400			bool SSL_set_session(Crypt::OpenSSL3::SSL ssl, Crypt::OpenSSL3::SSL::Session session)
1401
1402			bool SSL_session_reused(Crypt::OpenSSL3::SSL ssl)
1403
1404			void SSL_copy_session_id(Crypt::OpenSSL3::SSL to, Crypt::OpenSSL3::SSL from)
1405
1406			Crypt::OpenSSL3::X509 SSL_get_certificate(Crypt::OpenSSL3::SSL ssl)
1407			INTERFACE: SSL_get_certificate SSL_get_peer_certificate
1408			POSTCALL:
1409	0	0	if (RETVAL)
1410	0		X509_up_ref(RETVAL);
1411			else
1412	0		XSRETURN_UNDEF;
1413
1414			Crypt::OpenSSL3::PKey SSL_get_privatekey(Crypt::OpenSSL3::SSL ssl)
1415			POSTCALL:
1416	0	0	if (RETVAL)
1417	0		EVP_PKEY_up_ref(RETVAL);
1418			else
1419	0		XSRETURN_UNDEF;
1420
1421			Crypt::OpenSSL3::SSL::Cipher SSL_get_current_cipher(Crypt::OpenSSL3::SSL ssl)
1422			INTERFACE: SSL_get_current_cipher SSL_get_pending_cipher
1423			POSTCALL:
1424	0	0	if (!RETVAL)
1425	0		XSRETURN_UNDEF;
1426
1427			int SSL_client_version(Crypt::OpenSSL3::SSL s)
1428
1429			const char *SSL_get_version(Crypt::OpenSSL3::SSL ssl)
1430
1431			bool SSL_is_dtls(Crypt::OpenSSL3::SSL ssl)
1432
1433			bool SSL_is_tls(Crypt::OpenSSL3::SSL ssl)
1434
1435			bool SSL_is_quic(Crypt::OpenSSL3::SSL ssl)
1436
1437			bool SSL_in_init(Crypt::OpenSSL3::SSL s)
1438
1439			bool SSL_in_before(Crypt::OpenSSL3::SSL s)
1440
1441			bool SSL_is_init_finished(Crypt::OpenSSL3::SSL s)
1442
1443			bool SSL_in_connect_init(Crypt::OpenSSL3::SSL s)
1444
1445			bool SSL_in_accept_init(Crypt::OpenSSL3::SSL s)
1446
1447			int SSL_pending(Crypt::OpenSSL3::SSL ssl)
1448
1449			bool SSL_has_pending(Crypt::OpenSSL3::SSL s)
1450
1451			int SSL_version(Crypt::OpenSSL3::SSL s)
1452
1453			const char *SSL_state_string(Crypt::OpenSSL3::SSL ssl)
1454
1455			const char *SSL_state_string_long(Crypt::OpenSSL3::SSL ssl)
1456
1457			const char *SSL_rstate_string(Crypt::OpenSSL3::SSL ssl)
1458
1459			const char *SSL_rstate_string_long(Crypt::OpenSSL3::SSL ssl)
1460
1461			int SSL_set_num_tickets(Crypt::OpenSSL3::SSL s, size_t num_tickets)
1462
1463			size_t SSL_get_num_tickets(Crypt::OpenSSL3::SSL s)
1464
1465			bool SSL_new_session_ticket(Crypt::OpenSSL3::SSL s)
1466
1467			NO_OUTPUT size_t SSL_get_finished(Crypt::OpenSSL3::SSL ssl, OUTLIST SV* result)
1468			INIT:
1469	0		unsigned char* ptr = make_buffer(&result, EVP_MAX_MD_SIZE);
1470			C_ARGS: ssl, ptr, EVP_MAX_MD_SIZE
1471			POSTCALL:
1472	0	0	if (RETVAL)
1473	0		set_buffer_length(result, RETVAL);
1474
1475			NO_OUTPUT size_t SSL_get_peer_finished(Crypt::OpenSSL3::SSL ssl, OUTLIST SV* result)
1476			INIT:
1477	0		unsigned char* ptr = make_buffer(&result, EVP_MAX_MD_SIZE);
1478			C_ARGS: ssl, ptr, EVP_MAX_MD_SIZE
1479			POSTCALL:
1480	0	0	if (RETVAL)
1481	0		set_buffer_length(result, RETVAL);
1482
1483			void SSL_get_alpn_selected(Crypt::OpenSSL3::SSL s, OUTLIST SV* result)
1484			const unsigned char* ptr = NULL;
1485			unsigned int len = 0;
1486			C_ARGS: s, &ptr, &len
1487			POSTCALL:
1488	0		result = newSVpvn((char*)ptr, len);
1489
1490			#if OPENSSL_VERSION_PREREQ(3, 2)
1491
1492			bool SSL_set_blocking_mode(Crypt::OpenSSL3::SSL s, int blocking)
1493
1494			Success SSL_get_blocking_mode(Crypt::OpenSSL3::SSL s)
1495
1496			Crypt::OpenSSL3::SSL SSL_new_stream(Crypt::OpenSSL3::SSL ssl, uint64_t flags)
1497
1498			bool SSL_set_incoming_stream_policy(Crypt::OpenSSL3::SSL conn, int policy, uint64_t app_error_code = 0)
1499
1500			Crypt::OpenSSL3::SSL SSL_accept_stream(Crypt::OpenSSL3::SSL ssl, uint64_t flags)
1501
1502			size_t SSL_get_accept_stream_queue_len(Crypt::OpenSSL3::SSL ssl)
1503
1504			bool SSL_set_default_stream_mode(Crypt::OpenSSL3::SSL conn, unsigned mode)
1505
1506			bool SSL_stream_conclude(Crypt::OpenSSL3::SSL s, uint64_t flags)
1507
1508			bool SSL_stream_reset(Crypt::OpenSSL3::SSL ssl)
1509			C_ARGS: ssl, NULL, 0
1510
1511			int SSL_get_rpoll_descriptor(Crypt::OpenSSL3::SSL s, Crypt::OpenSSL3::BIO::PollDescriptor desc)
1512
1513			int SSL_get_wpoll_descriptor(Crypt::OpenSSL3::SSL s, Crypt::OpenSSL3::BIO::PollDescriptor desc)
1514
1515			bool SSL_net_read_desired(Crypt::OpenSSL3::SSL s)
1516
1517			bool SSL_net_write_desired(Crypt::OpenSSL3::SSL s)
1518
1519			Crypt::OpenSSL3::SSL SSL_get_connection(Crypt::OpenSSL3::SSL ssl)
1520			POSTCALL:
1521			SSL_up_ref(RETVAL);
1522
1523			bool SSL_is_connection(Crypt::OpenSSL3::SSL ssl)
1524
1525			uint64_t SSL_get_stream_id(Crypt::OpenSSL3::SSL ssl)
1526			POSTCALL:
1527			if (RETVAL == UINT64_MAX)
1528			XSRETURN_UNDEF;
1529
1530			int SSL_get_stream_type(Crypt::OpenSSL3::SSL ssl)
1531
1532			Success SSL_is_stream_local(Crypt::OpenSSL3::SSL ssl)
1533
1534			bool SSL_set_initial_peer_addr(Crypt::OpenSSL3::SSL s, Crypt::OpenSSL3::BIO::Address addr)
1535
1536			#endif
1537
1538
1539			#if OPENSSL_VERSION_PREREQ(3, 5)
1540
1541			Crypt::OpenSSL3::SSL SSL_new_listener(SV* classname, Crypt::OpenSSL3::SSL::Context ctx, uint64_t flags)
1542			C_ARGS: ctx, flags
1543
1544			Crypt::OpenSSL3::SSL SSL_new_listener_from(Crypt::OpenSSL3::SSL ssl, uint64_t flags)
1545
1546			bool SSL_is_listener(Crypt::OpenSSL3::SSL ssl)
1547
1548			Crypt::OpenSSL3::SSL SSL_get_listener(Crypt::OpenSSL3::SSL ssl)
1549			INTERFACE: SSL_get_listener SSL_get_domain
1550			POSTCALL:
1551			if (RETVAL)
1552			SSL_up_ref(RETVAL);
1553			else
1554			XSRETURN_UNDEF;
1555
1556			bool SSL_listen(Crypt::OpenSSL3::SSL ssl)
1557
1558			Crypt::OpenSSL3::SSL SSL_accept_connection(Crypt::OpenSSL3::SSL ssl, uint64_t flags)
1559
1560			size_t SSL_get_accept_connection_queue_len(Crypt::OpenSSL3::SSL ssl)
1561
1562			Crypt::OpenSSL3::SSL SSL_new_from_listener(Crypt::OpenSSL3::SSL ssl, uint64_t flags)
1563
1564			Crypt::OpenSSL3::SSL SSL_new_domain(Crypt::OpenSSL3::SSL::Context ctx, uint64_t flags)
1565
1566			bool SSL_is_domain(Crypt::OpenSSL3::SSL ssl)
1567
1568			NO_OUTPUT int SSL_get_domain_flags(Crypt::OpenSSL3::SSL ssl, OUTLIST uint64_t flags)
1569			POSTCALL:
1570			if (!RETVAL)
1571			XSRETURN_UNDEF;
1572
1573			#endif
1574
1575
1576			MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::SSL::Cipher PREFIX = SSL_CIPHER_
1577
1578			const char *SSL_CIPHER_get_name(Crypt::OpenSSL3::SSL::Cipher cipher)
1579
1580			const char *SSL_CIPHER_standard_name(Crypt::OpenSSL3::SSL::Cipher cipher)
1581
1582			NO_OUTPUT int SSL_CIPHER_get_bits(Crypt::OpenSSL3::SSL::Cipher cipher, OUTLIST int alg_bits)
1583			POSTCALL:
1584	0	0	if (!RETVAL)
1585	0		alg_bits = 0;
1586
1587			const char *SSL_CIPHER_get_version(Crypt::OpenSSL3::SSL::Cipher cipher)
1588
1589			NO_OUTPUT char SSL_CIPHER_description(Crypt::OpenSSL3::SSL::Cipher cipher, OUTLIST SV description, int length = 128)
1590			INIT:
1591	0		char* ptr = (char*)make_buffer(&description, length);
1592			C_ARGS: cipher, ptr, length
1593			POSTCALL:
1594	0	0	if (RETVAL)
1595	0		set_buffer_length(description, strlen(ptr));
1596
1597			int SSL_CIPHER_get_cipher_nid(Crypt::OpenSSL3::SSL::Cipher c)
1598
1599			int SSL_CIPHER_get_digest_nid(Crypt::OpenSSL3::SSL::Cipher c)
1600
1601			Crypt::OpenSSL3::MD SSL_CIPHER_get_handshake_digest(Crypt::OpenSSL3::SSL::Cipher c)
1602			POSTCALL:
1603	0	0	if (RETVAL)
1604	0		EVP_MD_up_ref(RETVAL);
1605			else
1606	0		XSRETURN_UNDEF;
1607
1608			int SSL_CIPHER_get_kx_nid(Crypt::OpenSSL3::SSL::Cipher c)
1609
1610			int SSL_CIPHER_get_auth_nid(Crypt::OpenSSL3::SSL::Cipher c)
1611
1612			bool SSL_CIPHER_is_aead(Crypt::OpenSSL3::SSL::Cipher c)
1613
1614			unsigned SSL_CIPHER_get_id(Crypt::OpenSSL3::SSL::Cipher c)
1615
1616			unsigned SSL_CIPHER_get_protocol_id(Crypt::OpenSSL3::SSL::Cipher c)
1617
1618
1619
1620			MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::SSL::Session PREFIX = SSL_SESSION_
1621
1622			Crypt::OpenSSL3::SSL::Session SSL_SESSION_new(class)
1623			C_ARGS:
1624
1625			Crypt::OpenSSL3::SSL::Session SSL_SESSION_dup(Crypt::OpenSSL3::SSL::Session s)
1626
1627			long SSL_SESSION_get_timeout(Crypt::OpenSSL3::SSL::Session s)
1628
1629			long SSL_SESSION_set_timeout(Crypt::OpenSSL3::SSL::Session s, long t)
1630
1631			int SSL_SESSION_get_protocol_version(Crypt::OpenSSL3::SSL::Session s)
1632
1633			int SSL_SESSION_set_protocol_version(Crypt::OpenSSL3::SSL::Session s, int version)
1634
1635			time_t SSL_SESSION_get_time(Crypt::OpenSSL3::SSL::Session s)
1636
1637			time_t SSL_SESSION_set_time(Crypt::OpenSSL3::SSL::Session s, time_t t)
1638
1639			const char *SSL_SESSION_get_hostname(Crypt::OpenSSL3::SSL::Session s)
1640
1641			bool SSL_SESSION_set_hostname(Crypt::OpenSSL3::SSL::Session s, const char *hostname)
1642
1643			void SSL_SESSION_get_alpn_selected(Crypt::OpenSSL3::SSL::Session s, OUTLIST SV* result)
1644			const unsigned char* ptr = NULL;
1645			size_t len = 0;
1646			C_ARGS: s, &ptr, &len
1647			POSTCALL:
1648	0		result = newSVpvn((char*)ptr, len);
1649
1650			bool SSL_SESSION_set_alpn_selected(Crypt::OpenSSL3::SSL::Session s, const unsigned char *alpn, size_t length(alpn))
1651
1652			Crypt::OpenSSL3::SSL::Cipher SSL_SESSION_get_cipher(Crypt::OpenSSL3::SSL::Session s)
1653
1654			bool SSL_SESSION_set_cipher(Crypt::OpenSSL3::SSL::Session s, Crypt::OpenSSL3::SSL::Cipher cipher)
1655
1656			bool SSL_SESSION_has_ticket(Crypt::OpenSSL3::SSL::Session s)
1657
1658			unsigned long SSL_SESSION_get_ticket_lifetime_hint(Crypt::OpenSSL3::SSL::Session s)
1659
1660			void SSL_SESSION_get_ticket(Crypt::OpenSSL3::SSL::Session s, OUTLIST SV* result)
1661			const unsigned char* ptr = NULL;
1662			size_t len = 0;
1663			C_ARGS: s, &ptr, &len
1664			POSTCALL:
1665	0		result = newSVpvn((char*)ptr, len);
1666
1667			unsigned SSL_SESSION_get_max_early_data(Crypt::OpenSSL3::SSL::Session s)
1668
1669			bool SSL_SESSION_set_max_early_data(Crypt::OpenSSL3::SSL::Session s, unsigned max_early_data)
1670
1671			Crypt::OpenSSL3::X509 SSL_SESSION_get_peer(Crypt::OpenSSL3::SSL::Session session)
1672			POSTCALL:
1673	0	0	if (RETVAL)
1674	0		X509_up_ref(RETVAL);
1675			else
1676	0		XSRETURN_UNDEF;
1677
1678			bool SSL_SESSION_set_id_context(Crypt::OpenSSL3::SSL::Session s, const unsigned char *sid_ctx, unsigned int length(sid_ctx))
1679
1680			bool SSL_SESSION_set_id(Crypt::OpenSSL3::SSL::Session s, const unsigned char *sid, unsigned int length(sid))
1681
1682			bool SSL_SESSION_is_resumable(Crypt::OpenSSL3::SSL::Session s)
1683
1684			NO_OUTPUT const unsigned char SSL_SESSION_get_id(Crypt::OpenSSL3::SSL::Session s, OUTLIST SV result)
1685			INTERFACE: SSL_SESSION_get_id SSL_SESSION_get_id_context
1686			INIT:
1687	0		unsigned int len = 0;
1688			C_ARGS: s, &len
1689			POSTCALL:
1690	0		result = newSVpvn((char*)RETVAL, len);
1691
1692			unsigned int SSL_SESSION_get_compress_id(Crypt::OpenSSL3::SSL::Session s)
1693
1694			bool SSL_SESSION_print(Crypt::OpenSSL3::BIO fp, Crypt::OpenSSL3::SSL::Session ses)
1695
1696			bool SSL_SESSION_print_keylog(Crypt::OpenSSL3::BIO bp, Crypt::OpenSSL3::SSL::Session x)
1697
1698
1699			MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::Random PREFIX = EVP_RAND_
1700
1701			Crypt::OpenSSL3::Random EVP_RAND_fetch(SV* classname, const char* algorithm, const char* properties = "")
1702			C_ARGS: NULL, algorithm, properties
1703			POSTCALL:
1704	0	0	if (RETVAL == NULL)
1705	0		XSRETURN_UNDEF;
1706
1707			bool EVP_RAND_is_a(Crypt::OpenSSL3::Random rand, const char *name)
1708
1709			const char *EVP_RAND_get_name(Crypt::OpenSSL3::Random rand)
1710
1711			const char *EVP_RAND_get_description(Crypt::OpenSSL3::Random rand)
1712
1713			void EVP_RAND_names_list_all(Crypt::OpenSSL3::Random rand)
1714			PPCODE:
1715	0		PUTBACK;
1716	0		EVP_RAND_names_do_all(rand, EVP_name_callback, iTHX);
1717	0		SPAGAIN;
1718
1719			void EVP_RAND_list_all_provided(SV* classname)
1720			PPCODE:
1721	0		PUTBACK;
1722	0		EVP_RAND_do_all_provided(NULL, EVP_RAND_provided_callback, iTHX);
1723	0		SPAGAIN;
1724
1725			SV* EVP_RAND_get_param(Crypt::OpenSSL3::Random rand, const char* name)
1726			CODE:
1727	0	0	GENERATE_GET_PARAM(EVP_RAND, rand, name)
		0
		0
		0
1728			OUTPUT:
1729			RETVAL
1730
1731			MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::Random PREFIX = RAND_
1732
1733			NO_OUTPUT int RAND_bytes(SV* classname, OUTLIST SV* buffer, int num)
1734			INTERFACE: RAND_bytes RAND_priv_bytes
1735			INIT:
1736	0		unsigned char* ptr = make_buffer(&buffer, num);
1737	0		set_buffer_length(buffer, num);
1738			C_ARGS: ptr, num
1739
1740			Crypt::OpenSSL3::Random::Context RAND_get_primary(SV* classname)
1741			INTERFACE: RAND_get_primary RAND_get_public RAND_get_private
1742			C_ARGS: NULL
1743			POSTCALL:
1744			EVP_RAND_CTX_up_ref(RETVAL);
1745
1746			#if OPENSSL_VERSION_PREREQ(3, 2)
1747			Bool RAND_set_public(SV* classname, Crypt::OpenSSL3::Random::Context rand)
1748			INTERFACE: RAND_set_public RAND_set_private
1749			C_ARGS: NULL, rand
1750			POSTCALL:
1751			if (RETVAL)
1752			EVP_RAND_CTX_up_ref(rand);
1753			#endif
1754
1755			MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::Random::Context PREFIX = EVP_RAND_CTX_
1756
1757			Crypt::OpenSSL3::Random::Context EVP_RAND_CTX_new(SV* classname, Crypt::OpenSSL3::Random type, Crypt::OpenSSL3::Random::Context parent = NULL)
1758			C_ARGS: type, parent
1759
1760			Crypt::OpenSSL3::Random EVP_RAND_CTX_get_rand(Crypt::OpenSSL3::Random::Context ctx)
1761			POSTCALL:
1762	0		EVP_RAND_up_ref(RETVAL);
1763
1764			MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::Random::Context PREFIX = EVP_RAND_
1765
1766			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)
1767
1768			bool EVP_RAND_uninstantiate(Crypt::OpenSSL3::Random::Context ctx)
1769
1770			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))
1771			INIT:
1772	0		unsigned char* ptr = make_buffer(&buffer, outlen);
1773			C_ARGS: ctx, ptr, outlen, strength, prediction_resistance, addin, XSauto_length_of_addin
1774			POSTCALL:
1775	0	0	if (RETVAL)
1776	0		set_buffer_length(buffer, outlen);
1777
1778			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)
1779
1780			NO_OUTPUT int EVP_RAND_nonce(Crypt::OpenSSL3::Random::Context ctx, OUTLIST SV* buffer, size_t outlen)
1781			INIT:
1782	0		unsigned char* ptr = make_buffer(&buffer, outlen);
1783			C_ARGS: ctx, ptr, outlen
1784			POSTCALL:
1785	0		set_buffer_length(buffer, RETVAL);
1786
1787			bool EVP_RAND_enable_locking(Crypt::OpenSSL3::Random::Context ctx)
1788
1789			bool EVP_RAND_verify_zeroization(Crypt::OpenSSL3::Random::Context ctx)
1790
1791			unsigned int EVP_RAND_get_strength(Crypt::OpenSSL3::Random::Context ctx)
1792
1793			int EVP_RAND_get_state(Crypt::OpenSSL3::Random::Context ctx)
1794
1795
1796			MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::Cipher PREFIX = EVP_CIPHER_
1797
1798			Crypt::OpenSSL3::Cipher EVP_CIPHER_fetch(SV* classname, const char* algorithm, const char* properties = "")
1799			C_ARGS: NULL, algorithm, properties
1800			POSTCALL:
1801	1	50	if (RETVAL == NULL)
1802	0		XSRETURN_UNDEF;
1803
1804			int EVP_CIPHER_get_nid(Crypt::OpenSSL3::Cipher e)
1805
1806			int EVP_CIPHER_get_block_size(Crypt::OpenSSL3::Cipher e)
1807
1808			int EVP_CIPHER_get_key_length(Crypt::OpenSSL3::Cipher e)
1809
1810			int EVP_CIPHER_get_iv_length(Crypt::OpenSSL3::Cipher e)
1811
1812			unsigned long EVP_CIPHER_get_mode(Crypt::OpenSSL3::Cipher e)
1813
1814			int EVP_CIPHER_get_type(Crypt::OpenSSL3::Cipher cipher)
1815
1816			bool EVP_CIPHER_is_a(Crypt::OpenSSL3::Cipher cipher, const char *name)
1817
1818			const char *EVP_CIPHER_get_name(Crypt::OpenSSL3::Cipher cipher)
1819
1820			const char *EVP_CIPHER_get_description(Crypt::OpenSSL3::Cipher cipher)
1821
1822			void EVP_CIPHER_names_list_all(Crypt::OpenSSL3::Cipher cipher)
1823			PPCODE:
1824	0		PUTBACK;
1825	0		EVP_CIPHER_names_do_all(cipher, EVP_name_callback, iTHX);
1826	0		SPAGAIN;
1827
1828			void EVP_CIPHER_list_all_provided(SV* classname)
1829			PPCODE:
1830	1		PUTBACK;
1831	1		EVP_CIPHER_do_all_provided(NULL, EVP_CIPHER_provided_callback, iTHX);
1832	1		SPAGAIN;
1833
1834			SV* EVP_CIPHER_get_param(Crypt::OpenSSL3::Cipher cipher, const char* name)
1835			CODE:
1836	0	0	GENERATE_GET_PARAM(EVP_CIPHER, cipher, name)
		0
		0
		0
1837			OUTPUT:
1838			RETVAL
1839
1840
1841			MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::Cipher::Context PREFIX = EVP_CIPHER_CTX_
1842
1843			Crypt::OpenSSL3::Cipher::Context EVP_CIPHER_CTX_new(SV* classname)
1844			C_ARGS:
1845
1846			Crypt::OpenSSL3::Cipher::Context EVP_CIPHER_CTX_dup(Crypt::OpenSSL3::Cipher::Context ctx)
1847
1848			bool EVP_CIPHER_CTX_copy(Crypt::OpenSSL3::Cipher::Context self, Crypt::OpenSSL3::Cipher::Context other)
1849
1850			bool EVP_CIPHER_CTX_reset(Crypt::OpenSSL3::Cipher::Context ctx)
1851
1852			bool EVP_CIPHER_CTX_init(Crypt::OpenSSL3::Cipher::Context ctx, Crypt::OpenSSL3::Cipher type, const unsigned char* key, size_t length(key), const unsigned char* iv, size_t length(iv), bool enc, CTX_PARAMS(EVP_CIPHER) params = NULL)
1853			INIT:
1854	2	50	if (XSauto_length_of_key != EVP_CIPHER_get_key_length(type) \|\| XSauto_length_of_iv != EVP_CIPHER_get_iv_length(type))
		50
1855	0		XSRETURN_NO;
1856			C_ARGS: ctx, type, key, iv, enc, params
1857
1858			NO_OUTPUT int EVP_CIPHER_CTX_update(Crypt::OpenSSL3::Cipher::Context ctx, const unsigned char* input, size_t length(input), OUTLIST SV* output)
1859			INIT:
1860	2		int outl = XSauto_length_of_input + EVP_CIPHER_CTX_get_block_size(ctx);
1861	2		unsigned char* ptr = make_buffer(&output, outl);
1862			C_ARGS: ctx, ptr, &outl, input, XSauto_length_of_input
1863			POSTCALL:
1864	2	50	if (RETVAL)
1865	2		set_buffer_length(output, outl);
1866
1867			NO_OUTPUT int EVP_CIPHER_CTX_final(Crypt::OpenSSL3::Cipher::Context ctx, OUTLIST SV* output)
1868			INIT:
1869	2		int size = EVP_CIPHER_CTX_get_block_size(ctx);
1870	2		unsigned char* ptr = make_buffer(&output, size);
1871			C_ARGS: ctx, ptr, &size
1872			POSTCALL:
1873	2	50	if (RETVAL)
1874	2		set_buffer_length(output, size);
1875
1876			bool EVP_CIPHER_CTX_set_params(Crypt::OpenSSL3::Cipher::Context ctx, PARAMS(EVP_CIPHER_CTX) params = NULL)
1877
1878			SV* EVP_CIPHER_CTX_get_param(Crypt::OpenSSL3::Cipher::Context ctx, const char* name)
1879			CODE:
1880	1	50	GENERATE_GET_PARAM(EVP_CIPHER_CTX, ctx, name)
		50
		50
		50
1881			OUTPUT:
1882			RETVAL
1883
1884
1885			int EVP_CIPHER_CTX_get_nid(Crypt::OpenSSL3::Cipher::Context e)
1886
1887			int EVP_CIPHER_CTX_get_block_size(Crypt::OpenSSL3::Cipher::Context e)
1888
1889			int EVP_CIPHER_CTX_get_key_length(Crypt::OpenSSL3::Cipher::Context e)
1890
1891			int EVP_CIPHER_CTX_get_iv_length(Crypt::OpenSSL3::Cipher::Context e)
1892
1893			unsigned long EVP_CIPHER_CTX_get_mode(Crypt::OpenSSL3::Cipher::Context e)
1894
1895			int EVP_CIPHER_CTX_type(Crypt::OpenSSL3::Cipher::Context ctx)
1896
1897			bool EVP_CIPHER_CTX_set_padding(Crypt::OpenSSL3::Cipher::Context ctx, int padding)
1898
1899			bool EVP_CIPHER_CTX_set_key_length(Crypt::OpenSSL3::Cipher::Context ctx, int keylen)
1900
1901			int EVP_CIPHER_CTX_ctrl(Crypt::OpenSSL3::Cipher::Context ctx, int cmd, int p1, char *p2)
1902
1903			NO_OUTPUT int EVP_CIPHER_CTX_rand_key(Crypt::OpenSSL3::Cipher::Context ctx, OUTLIST SV* key)
1904			INIT:
1905	0		size_t size = EVP_CIPHER_CTX_key_length(ctx);
1906	0		unsigned char* ptr = make_buffer(&key, size);
1907			C_ARGS: ctx, ptr
1908			POSTCALL:
1909	0	0	if (RETVAL > 0)
1910	0		set_buffer_length(key, size);
1911
1912			Crypt::OpenSSL3::Cipher EVP_CIPHER_CTX_get_cipher(Crypt::OpenSSL3::Cipher::Context ctx)
1913
1914			const char *EVP_CIPHER_CTX_get_name(Crypt::OpenSSL3::Cipher::Context ctx)
1915
1916			bool EVP_CIPHER_CTX_is_encrypting(Crypt::OpenSSL3::Cipher::Context ctx)
1917
1918			bool EVP_CIPHER_CTX_set_aead_ivlen(Crypt::OpenSSL3::Cipher::Context ctx, int length)
1919
1920			NO_OUTPUT bool EVP_CIPHER_CTX_get_aead_tag(Crypt::OpenSSL3::Cipher::Context ctx, OUTLIST SV* tag)
1921			INIT:
1922	1		int length = EVP_CIPHER_CTX_get_tag_length(ctx);
1923	1		unsigned char* ptr = make_buffer(&tag, length);
1924			C_ARGS: ctx, ptr, length
1925			POSTCALL:
1926	1	50	if (RETVAL)
1927	1		set_buffer_length(tag, length);
1928
1929			bool EVP_CIPHER_CTX_set_aead_tag(Crypt::OpenSSL3::Cipher::Context ctx, char* ptr, int length(ptr))
1930
1931
1932			MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::MD PREFIX = EVP_MD_
1933
1934			Crypt::OpenSSL3::MD EVP_MD_fetch(SV* classname, const char* algorithm, const char* properties = "")
1935			C_ARGS: NULL, algorithm, properties
1936			POSTCALL:
1937	1	50	if (RETVAL == NULL)
1938	0		XSRETURN_UNDEF;
1939
1940			const char *EVP_MD_get_name(Crypt::OpenSSL3::MD md)
1941
1942			const char *EVP_MD_get_description(Crypt::OpenSSL3::MD md)
1943
1944			bool EVP_MD_is_a(Crypt::OpenSSL3::MD md, const char *name)
1945
1946			void EVP_MD_names_list_all(Crypt::OpenSSL3::MD md)
1947			PPCODE:
1948	0		PUTBACK;
1949	0		EVP_MD_names_do_all(md, EVP_name_callback, iTHX);
1950	0		SPAGAIN;
1951
1952			void EVP_MD_list_all_provided(SV* classname)
1953			PPCODE:
1954	1		PUTBACK;
1955	1		EVP_MD_do_all_provided(NULL, EVP_MD_provided_callback, iTHX);
1956	1		SPAGAIN;
1957
1958			int EVP_MD_get_type(Crypt::OpenSSL3::MD md)
1959
1960			int EVP_MD_get_pkey_type(Crypt::OpenSSL3::MD md)
1961
1962			int EVP_MD_get_size(Crypt::OpenSSL3::MD md)
1963
1964			int EVP_MD_get_block_size(Crypt::OpenSSL3::MD md)
1965
1966			unsigned long EVP_MD_get_flags(Crypt::OpenSSL3::MD md)
1967
1968			#if OPENSSL_VERSION_PREREQ(3, 4)
1969			bool EVP_MD_xof(Crypt::OpenSSL3::MD md)
1970			#endif
1971
1972			SV* EVP_MD_get_param(Crypt::OpenSSL3::MD md, const char* name)
1973			CODE:
1974	0	0	GENERATE_GET_PARAM(EVP_MD, md, name)
		0
		0
		0
1975			OUTPUT:
1976			RETVAL
1977
1978			NO_OUTPUT bool EVP_MD_digest(Crypt::OpenSSL3::MD md, const char* input, size_t length(input), OUTLIST SV* digest)
1979			INIT:
1980	0		unsigned int size = EVP_MD_get_size(md);
1981	0		unsigned char* ptr = make_buffer(&digest, size);
1982			C_ARGS: input, XSauto_length_of_input, ptr, &size, md, NULL
1983			POSTCALL:
1984	0	0	if (RETVAL)
1985	0		set_buffer_length(digest, size);
1986
1987
1988			MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::MD::Context PREFIX = EVP_MD_CTX_
1989
1990			Crypt::OpenSSL3::MD::Context EVP_MD_CTX_new(SV* classname)
1991			C_ARGS:
1992
1993			Crypt::OpenSSL3::MD::Context EVP_MD_CTX_dup(Crypt::OpenSSL3::MD::Context ctx)
1994
1995			bool EVP_MD_CTX_copy(Crypt::OpenSSL3::MD::Context self, Crypt::OpenSSL3::MD::Context other)
1996
1997			bool EVP_MD_CTX_reset(Crypt::OpenSSL3::MD::Context ctx)
1998
1999			bool EVP_MD_CTX_init(Crypt::OpenSSL3::MD::Context ctx, Crypt::OpenSSL3::MD type, CTX_PARAMS(EVP_MD) params = NULL)
2000
2001			bool EVP_MD_CTX_update(Crypt::OpenSSL3::MD::Context ctx, const char *d, size_t length(d))
2002
2003			NO_OUTPUT bool EVP_MD_CTX_final(Crypt::OpenSSL3::MD::Context ctx, OUTLIST SV* digest)
2004			INIT:
2005	1		unsigned int size = EVP_MD_CTX_size(ctx);
2006	1		unsigned char* ptr = make_buffer(&digest , size);
2007			C_ARGS: ctx, ptr, &size
2008			POSTCALL:
2009	1	50	if (RETVAL)
2010	1		set_buffer_length(digest, size);
2011
2012			NO_OUTPUT bool EVP_MD_CTX_final_xof(Crypt::OpenSSL3::MD::Context ctx, OUTLIST SV* digest, size_t outlen)
2013			INIT:
2014	0		unsigned char* ptr = make_buffer(&digest, outlen);
2015			C_ARGS: ctx, ptr, outlen
2016			POSTCALL:
2017	0	0	if (RETVAL)
2018	0		set_buffer_length(digest, outlen);
2019
2020			#if OPENSSL_VERSION_PREREQ(3, 3)
2021			NO_OUTPUT bool EVP_MD_CTX_squeeze(Crypt::OpenSSL3::MD::Context ctx, OUTLIST SV* digest, size_t outlen)
2022			INIT:
2023			unsigned char* ptr = make_buffer(&digest, outlen);
2024			C_ARGS: ctx, ptr, outlen
2025			POSTCALL:
2026			if (RETVAL)
2027			set_buffer_length(digest, outlen);
2028			#endif
2029
2030			bool EVP_MD_CTX_sign_init(Crypt::OpenSSL3::MD::Context ctx, Crypt::OpenSSL3::MD type, Crypt::OpenSSL3::PKey pkey, Crypt::OpenSSL3::PKey::Context pctx = NULL)
2031			C_ARGS: ctx, pctx ? &pctx : NULL, type, NULL, pkey
2032
2033			bool EVP_MD_CTX_sign_update(Crypt::OpenSSL3::MD::Context ctx, const char *d, size_t length(d))
2034
2035			SV* EVP_MD_CTX_sign_final(Crypt::OpenSSL3::MD::Context ctx)
2036			CODE:
2037	1		size_t size = 0;
2038	1	50	if (EVP_DigestSignFinal(ctx, NULL, &size) == 1) {
2039	1		unsigned char* ptr = make_buffer(&RETVAL, size);
2040	1	50	if (EVP_DigestSignFinal(ctx, ptr, &size) == 1)
2041	1		set_buffer_length(RETVAL, size);
2042			} else
2043	0		RETVAL = &PL_sv_undef;
2044			OUTPUT:
2045			RETVAL
2046
2047			SV* EVP_MD_CTX_sign(Crypt::OpenSSL3::MD::Context ctx, const unsigned char *tbs, size_t length(tbs))
2048			CODE:
2049	0		size_t size = 0;
2050	0	0	if (EVP_DigestSign(ctx, NULL, &size, tbs, XSauto_length_of_tbs) == 1) {
2051	0		unsigned char* ptr = make_buffer(&RETVAL, size);
2052	0	0	if (EVP_DigestSign(ctx, ptr, &size, tbs, XSauto_length_of_tbs) == 1)
2053	0		set_buffer_length(RETVAL, size);
2054			} else
2055	0		RETVAL = &PL_sv_undef;
2056			OUTPUT:
2057			RETVAL
2058
2059			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)
2060			C_ARGS: ctx, pctx ? &pctx : NULL, type, NULL, pkey
2061
2062			bool EVP_MD_CTX_verify_update(Crypt::OpenSSL3::MD::Context ctx, const char *d, size_t length(d))
2063
2064			Success EVP_MD_CTX_verify_final(Crypt::OpenSSL3::MD::Context ctx, const unsigned char *sig, size_t length(sig))
2065
2066			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))
2067
2068			bool EVP_MD_CTX_set_params(Crypt::OpenSSL3::MD::Context ctx, PARAMS(EVP_MD_CTX) params = NULL)
2069
2070			SV* EVP_MD_CTX_get_param(Crypt::OpenSSL3::MD::Context ctx, const char* name)
2071			CODE:
2072	0	0	GENERATE_GET_PARAM(EVP_MD_CTX, ctx, name)
		0
		0
		0
2073			OUTPUT:
2074			RETVAL
2075
2076
2077			void EVP_MD_CTX_ctrl(Crypt::OpenSSL3::MD::Context ctx, int cmd, int p1, char* p2);
2078
2079			void EVP_MD_CTX_set_flags(Crypt::OpenSSL3::MD::Context ctx, int flags)
2080
2081			void EVP_MD_CTX_clear_flags(Crypt::OpenSSL3::MD::Context ctx, int flags)
2082
2083			int EVP_MD_CTX_test_flags(Crypt::OpenSSL3::MD::Context ctx, int flags)
2084
2085			Crypt::OpenSSL3::MD EVP_MD_CTX_get_md(Crypt::OpenSSL3::MD::Context ctx)
2086
2087			const char *EVP_MD_CTX_get_name(Crypt::OpenSSL3::MD::Context ctx)
2088
2089			int EVP_MD_CTX_get_size(Crypt::OpenSSL3::MD::Context ctx)
2090
2091			int EVP_MD_CTX_get_block_size(Crypt::OpenSSL3::MD::Context ctx)
2092
2093			int EVP_MD_CTX_get_type(Crypt::OpenSSL3::MD::Context ctx)
2094
2095
2096
2097			MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::MAC PREFIX = EVP_MAC_
2098
2099			Crypt::OpenSSL3::MAC EVP_MAC_fetch(SV* classname, const char* algorithm, const char* properties = "")
2100			C_ARGS: NULL, algorithm, properties
2101			POSTCALL:
2102	1	50	if (RETVAL == NULL)
2103	0		XSRETURN_UNDEF;
2104
2105			const char *EVP_MAC_get_name(Crypt::OpenSSL3::MAC mac)
2106
2107			const char *EVP_MAC_get_description(Crypt::OpenSSL3::MAC mac)
2108
2109			bool EVP_MAC_is_a(Crypt::OpenSSL3::MAC mac, const char *name)
2110
2111			void EVP_MAC_names_list_all(Crypt::OpenSSL3::MAC mac, SV* callback)
2112			PPCODE:
2113	0		PUTBACK;
2114	0		EVP_MAC_names_do_all(mac, EVP_name_callback, iTHX);
2115	0		SPAGAIN;
2116
2117			void EVP_MAC_list_all_provided(SV* classname)
2118			PPCODE:
2119	1		PUTBACK;
2120	1		EVP_MAC_do_all_provided(NULL, EVP_MAC_provided_callback, iTHX);
2121	1		SPAGAIN;
2122
2123			SV* EVP_MAC_get_param(Crypt::OpenSSL3::MAC mac, const char* name)
2124			CODE:
2125	0	0	GENERATE_GET_PARAM(EVP_MAC, mac, name)
		0
		0
		0
2126			OUTPUT:
2127			RETVAL
2128
2129
2130
2131			MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::MAC::Context PREFIX = EVP_MAC_CTX_
2132
2133			Crypt::OpenSSL3::MAC::Context EVP_MAC_CTX_new(SV* classname, Crypt::OpenSSL3::MAC ctx)
2134			C_ARGS: ctx
2135
2136			Crypt::OpenSSL3::MAC::Context EVP_MAC_CTX_dup(Crypt::OpenSSL3::MAC::Context ctx)
2137
2138			Crypt::OpenSSL3::MAC EVP_MAC_CTX_get_mac(Crypt::OpenSSL3::MAC::Context ctx);
2139			POSTCALL:
2140	0		EVP_MAC_up_ref(RETVAL);
2141
2142			size_t EVP_MAC_CTX_get_mac_size(Crypt::OpenSSL3::MAC::Context ctx)
2143
2144			size_t EVP_MAC_CTX_get_block_size(Crypt::OpenSSL3::MAC::Context ctx)
2145
2146			bool EVP_MAC_CTX_set_params(Crypt::OpenSSL3::MAC::Context ctx, PARAMS(EVP_MAC_CTX) params = NULL)
2147
2148			SV* EVP_MAC_CTX_get_param(Crypt::OpenSSL3::MAC::Context ctx, const char* name)
2149			CODE:
2150	0	0	GENERATE_GET_PARAM(EVP_MAC_CTX, ctx, name)
		0
		0
		0
2151			OUTPUT:
2152			RETVAL
2153
2154
2155
2156			MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::MAC::Context PREFIX = EVP_MAC_
2157
2158			bool EVP_MAC_init(Crypt::OpenSSL3::MAC::Context ctx, const unsigned char *key, size_t length(key), PARAMS(EVP_MAC_CTX) params = NULL)
2159
2160			bool EVP_MAC_update(Crypt::OpenSSL3::MAC::Context ctx, const unsigned char *data, size_t length(data))
2161
2162			NO_OUTPUT bool EVP_MAC_final(Crypt::OpenSSL3::MAC::Context ctx, OUTLIST SV* code)
2163			CODE:
2164			size_t outsize;
2165	1		EVP_MAC_final(ctx, NULL, &outsize, 0);
2166	1		unsigned char* ptr = make_buffer(&code, outsize);
2167	1		int result = EVP_MAC_final(ctx, ptr, &outsize, outsize);
2168	1	50	if (result)
2169	1		set_buffer_length(code, outsize);
2170
2171			NO_OUTPUT int EVP_MAC_finalXOF(Crypt::OpenSSL3::MAC::Context ctx, OUTLIST SV* code, size_t outsize)
2172			INIT:
2173	0		unsigned char* ptr = make_buffer(&code, outsize);
2174			C_ARGS: ctx, ptr, outsize
2175			POSTCALL:
2176	0	0	if (RETVAL)
2177	0		set_buffer_length(code, outsize);
2178
2179
2180
2181			MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::KDF PREFIX = EVP_KDF_
2182
2183			Crypt::OpenSSL3::KDF EVP_KDF_fetch(SV* classname, const char* algorithm, const char* properties = "")
2184			C_ARGS: NULL, algorithm, properties
2185			POSTCALL:
2186	1	50	if (RETVAL == NULL)
2187	0		XSRETURN_UNDEF;
2188
2189			const char *EVP_KDF_get_name(Crypt::OpenSSL3::KDF kdf)
2190
2191			const char *EVP_KDF_get_description(Crypt::OpenSSL3::KDF kdf)
2192
2193			bool EVP_KDF_is_a(Crypt::OpenSSL3::KDF kdf, const char *name)
2194
2195			void EVP_KDF_names_list_all(Crypt::OpenSSL3::KDF kdf)
2196			PPCODE:
2197	0		PUTBACK;
2198	0		EVP_KDF_names_do_all(kdf, EVP_name_callback, iTHX);
2199	0		SPAGAIN;
2200
2201			void EVP_KDF_list_all_provided(SV* classname)
2202			PPCODE:
2203	1		PUTBACK;
2204	1		EVP_KDF_do_all_provided(NULL, EVP_KDF_provided_callback, iTHX);
2205	1		SPAGAIN;
2206
2207			SV* EVP_KDF_get_param(Crypt::OpenSSL3::KDF kdf, const char* name)
2208			CODE:
2209	0	0	GENERATE_GET_PARAM(EVP_KDF, kdf, name)
		0
		0
		0
2210			OUTPUT:
2211			RETVAL
2212
2213
2214			MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::KDF::Context PREFIX = EVP_KDF_CTX_
2215
2216			Crypt::OpenSSL3::KDF::Context EVP_KDF_CTX_new(SV* classname, Crypt::OpenSSL3::KDF ctx)
2217			C_ARGS: ctx
2218
2219			Crypt::OpenSSL3::KDF::Context EVP_KDF_CTX_dup(Crypt::OpenSSL3::KDF::Context ctx)
2220
2221			void EVP_KDF_CTX_reset(Crypt::OpenSSL3::KDF::Context ctx)
2222
2223			size_t EVP_KDF_CTX_get_kdf_size(Crypt::OpenSSL3::KDF::Context ctx)
2224
2225			bool EVP_KDF_CTX_set_params(Crypt::OpenSSL3::KDF::Context ctx, PARAMS(EVP_KDF_CTX) params = NULL)
2226
2227			SV* EVP_KDF_CTX_get_param(Crypt::OpenSSL3::KDF::Context ctx, const char* name)
2228			CODE:
2229	0	0	GENERATE_GET_PARAM(EVP_KDF_CTX, ctx, name)
		0
		0
		0
2230			OUTPUT:
2231			RETVAL
2232
2233			Crypt::OpenSSL3::KDF EVP_KDF_CTX_kdf(Crypt::OpenSSL3::KDF::Context ctx)
2234			POSTCALL:
2235	0		EVP_KDF_up_ref(RETVAL);
2236
2237
2238			MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::KDF::Context PREFIX = EVP_KDF_
2239
2240			NO_OUTPUT bool EVP_KDF_derive(Crypt::OpenSSL3::KDF::Context ctx, OUTLIST SV* derived, size_t keylen, PARAMS(EVP_KDF_CTX) params)
2241			INIT:
2242	1		unsigned char* ptr = make_buffer(&derived, keylen);
2243			C_ARGS: ctx, ptr, keylen, params
2244			POSTCALL:
2245	1	50	if (RETVAL)
2246	1		set_buffer_length(derived, keylen);
2247
2248
2249
2250			MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::Signature PREFIX = EVP_SIGNATURE_
2251
2252			Crypt::OpenSSL3::Signature EVP_SIGNATURE_fetch(SV* classname, const char* algorithm, const char* properties = "")
2253			C_ARGS: NULL, algorithm, properties
2254			POSTCALL:
2255	0	0	if (RETVAL == NULL)
2256	0		XSRETURN_UNDEF;
2257
2258			const char *EVP_SIGNATURE_get_name(Crypt::OpenSSL3::Signature signature)
2259
2260			const char *EVP_SIGNATURE_get_description(Crypt::OpenSSL3::Signature signature)
2261
2262			bool EVP_SIGNATURE_is_a(Crypt::OpenSSL3::Signature signature, const char *name)
2263
2264			void EVP_SIGNATURE_names_list_all(Crypt::OpenSSL3::Signature signature)
2265			PPCODE:
2266	0		PUTBACK;
2267	0		EVP_SIGNATURE_names_do_all(signature, EVP_name_callback, iTHX);
2268	0		SPAGAIN;
2269
2270			void EVP_SIGNATURE_list_all_provided(SV* classname)
2271			PPCODE:
2272	0		PUTBACK;
2273	0		EVP_SIGNATURE_do_all_provided(NULL, EVP_SIGNATURE_provided_callback, iTHX);
2274	0		SPAGAIN;
2275
2276
2277			MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::PKey PREFIX = EVP_PKEY_
2278
2279			Crypt::OpenSSL3::PKey EVP_PKEY_new(SV* classname)
2280			C_ARGS:
2281
2282			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 = "")
2283			C_ARGS: NULL, keytype, propq, key, XSauto_length_of_key
2284			POSTCALL:
2285	0	0	if (RETVAL == NULL)
2286	0		XSRETURN_UNDEF;
2287
2288			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 = "")
2289			C_ARGS: NULL, keytype, propq, key, XSauto_length_of_key
2290			POSTCALL:
2291	0	0	if (RETVAL == NULL)
2292	0		XSRETURN_UNDEF;
2293
2294			Crypt::OpenSSL3::PKey EVP_PKEY_dup(Crypt::OpenSSL3::PKey ctx)
2295
2296			bool EVP_PKEY_eq(Crypt::OpenSSL3::PKey a, Crypt::OpenSSL3::PKey b)
2297
2298			bool EVP_PKEY_parameters_eq(Crypt::OpenSSL3::PKey a, Crypt::OpenSSL3::PKey b)
2299
2300			NO_OUTPUT void EVP_PKEY_get_raw_private_key(Crypt::OpenSSL3::PKey pkey, OUTLIST SV* key)
2301			CODE:
2302			size_t length;
2303	0		int result = EVP_PKEY_get_raw_private_key(pkey, NULL, &length);
2304	0	0	if (!result)
2305	0		XSRETURN_UNDEF;
2306	0		unsigned char* ptr = make_buffer(&key, length);
2307	0		result = EVP_PKEY_get_raw_private_key(pkey, ptr, &length);
2308	0	0	if (result)
2309	0		set_buffer_length(key, length);
2310
2311
2312			NO_OUTPUT void EVP_PKEY_get_raw_public_key(Crypt::OpenSSL3::PKey pkey, OUTLIST SV* key)
2313			CODE:
2314			size_t length;
2315	0		int result = EVP_PKEY_get_raw_public_key(pkey, NULL, &length);
2316	0	0	if (!result)
2317	0		XSRETURN_UNDEF;
2318	0		unsigned char* ptr = make_buffer(&key, length);
2319	0		result = EVP_PKEY_get_raw_public_key(pkey, ptr, &length);
2320	0	0	if (result)
2321	0		set_buffer_length(key, length);
2322
2323			Crypt::OpenSSL3::PKey EVP_PKEY_read_pem_private_key(Crypt::OpenSSL3::BIO bio, SV* password_cb = undef, const char* propq = "")
2324			C_ARGS: bio, NULL, NULL, NULL, NULL, propq
2325			POSTCALL:
2326	0	0	if (!RETVAL)
2327	0		XSRETURN_UNDEF;
2328
2329			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 = "")
2330			INIT:
2331	0	0	const EVP_CIPHER* cipher = SvOK(cipher_sv) ? get_EVP_CIPHER(aTHX_ cipher_sv) : NULL;
2332	0		STRLEN klen = 0;
2333	0		const unsigned char* kstr = NULL;
2334	0	0	if (SvOK(key))
2335	0		kstr = (unsigned char*)SvPV(key, klen);
2336			C_ARGS: bio, pkey, cipher, kstr, klen, NULL, NULL, NULL, propq
2337
2338			Crypt::OpenSSL3::PKey EVP_PKEY_read_pem_public_key(Crypt::OpenSSL3::BIO bio, const char* propq = "")
2339			C_ARGS: bio, NULL, NULL, NULL, NULL, propq
2340			POSTCALL:
2341	0	0	if (!RETVAL)
2342	0		XSRETURN_UNDEF;
2343
2344			bool EVP_PKEY_write_pem_public_key(Crypt::OpenSSL3::PKey pkey, Crypt::OpenSSL3::BIO bio, const char* propq = "")
2345			C_ARGS: bio, pkey, NULL, propq
2346
2347			int EVP_PKEY_get_id(Crypt::OpenSSL3::PKey pkey)
2348
2349			int EVP_PKEY_get_base_id(Crypt::OpenSSL3::PKey pkey)
2350
2351			int EVP_PKEY_type(int type)
2352
2353			bool EVP_PKEY_set_type(Crypt::OpenSSL3::PKey pkey, int type)
2354
2355			bool EVP_PKEY_set_type_str(Crypt::OpenSSL3::PKey pkey, const char *str, int length(str))
2356
2357			int EVP_PKEY_get_size(Crypt::OpenSSL3::PKey pkey)
2358
2359			int EVP_PKEY_get_bits(Crypt::OpenSSL3::PKey pkey)
2360
2361			int EVP_PKEY_get_security_bits(Crypt::OpenSSL3::PKey pkey)
2362
2363			bool EVP_PKEY_is_a(Crypt::OpenSSL3::PKey pkey, const char *name)
2364
2365			bool EVP_PKEY_can_sign(Crypt::OpenSSL3::PKey pkey)
2366
2367			void EVP_PKEY_type_names_list_all(Crypt::OpenSSL3::PKey pkey)
2368			PPCODE:
2369	0		PUTBACK;
2370	0		EVP_PKEY_type_names_do_all(pkey, EVP_name_callback, iTHX);
2371	0		SPAGAIN;
2372
2373			const char *EVP_PKEY_get_type_name(Crypt::OpenSSL3::PKey key)
2374
2375			const char *EVP_PKEY_get_description(Crypt::OpenSSL3::PKey key)
2376
2377			Success EVP_PKEY_digestsign_supports_digest(Crypt::OpenSSL3::PKey pkey, const char name, const char propq)
2378			C_ARGS: pkey, NULL, name, propq
2379
2380			NO_OUTPUT int EVP_PKEY_get_default_digest_name(Crypt::OpenSSL3::PKey pkey, OUTLIST SV* mdname)
2381			INIT:
2382	0		char* ptr = (char*)make_buffer(&mdname, 32);
2383			C_ARGS: pkey, ptr, 32
2384			POSTCALL:
2385	0	0	if (RETVAL > 0)
2386	0		set_buffer_length(mdname, strlen(SvPV_nolen(mdname)));
2387
2388			NO_OUTPUT int EVP_PKEY_get_default_digest_nid(Crypt::OpenSSL3::PKey pkey, OUTLIST int pnid)
2389			POSTCALL:
2390	0	0	if (RETVAL <= 0)
2391	0		XSRETURN_UNDEF;
2392
2393			int EVP_PKEY_get_field_type(Crypt::OpenSSL3::PKey pkey)
2394
2395			int EVP_PKEY_get_ec_point_conv_form(Crypt::OpenSSL3::PKey pkey)
2396
2397			NO_OUTPUT int EVP_PKEY_get_group_name(Crypt::OpenSSL3::PKey pkey, OUTLIST SV* name, size_t size = 32)
2398			INIT:
2399	0		char* ptr = (char*)make_buffer(&name, size);
2400			C_ARGS: pkey, ptr, size + 1, &size
2401			POSTCALL:
2402	0	0	if (RETVAL)
2403	0		set_buffer_length(name, size);
2404
2405			bool EVP_PKEY_set_encoded_public_key(Crypt::OpenSSL3::PKey pkey, const unsigned char *pub, size_t length(pub))
2406
2407			NO_OUTPUT size_t EVP_PKEY_get_encoded_public_key(Crypt::OpenSSL3::PKey pkey, OUTLIST SV* result)
2408			INIT:
2409	0		unsigned char* ptr = NULL;
2410			C_ARGS: pkey, &ptr
2411			POSTCALL:
2412	0	0	result = RETVAL > 0 ? newSVpvn((char*)ptr, RETVAL) : &PL_sv_undef;
2413	0		OPENSSL_free(ptr);
2414
2415			SV* EVP_PKEY_get_param(Crypt::OpenSSL3::PKey pkey, const char* name)
2416			CODE:
2417	0	0	GENERATE_GET_PARAM(EVP_PKEY, pkey, name)
		0
		0
		0
2418			OUTPUT:
2419			RETVAL
2420
2421			bool EVP_PKEY_get_int_param(Crypt::OpenSSL3::PKey pkey, const char *key_name, OUT int out)
2422
2423			bool EVP_PKEY_get_size_t_param(Crypt::OpenSSL3::PKey pkey, const char *key_name, OUT size_t out)
2424
2425			bool EVP_PKEY_get_bn_param(Crypt::OpenSSL3::PKey pkey, const char *key_name, OUT Crypt::OpenSSL3::BigNum bn)
2426
2427			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)
2428
2429			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)
2430
2431			bool EVP_PKEY_set_params(Crypt::OpenSSL3::PKey ctx, PARAMS(EVP_PKEY) params = NULL)
2432
2433			bool EVP_PKEY_set_int_param(Crypt::OpenSSL3::PKey pkey, const char *key_name, int in)
2434
2435			bool EVP_PKEY_set_size_t_param(Crypt::OpenSSL3::PKey pkey, const char *key_name, size_t in)
2436
2437			bool EVP_PKEY_set_bn_param(Crypt::OpenSSL3::PKey pkey, const char *key_name, Crypt::OpenSSL3::BigNum bn)
2438
2439			bool EVP_PKEY_set_utf8_string_param(Crypt::OpenSSL3::PKey pkey, const char key_name, const char str)
2440
2441			bool EVP_PKEY_set_octet_string_param(Crypt::OpenSSL3::PKey pkey, const char key_name, const unsigned char buf, size_t length(buf))
2442
2443			Success EVP_PKEY_print_public(Crypt::OpenSSL3::BIO out, Crypt::OpenSSL3::PKey pkey, int indent)
2444			C_ARGS: out, pkey, indent, NULL
2445
2446			Success EVP_PKEY_print_private(Crypt::OpenSSL3::BIO out, Crypt::OpenSSL3::PKey pkey, int indent)
2447			C_ARGS: out, pkey, indent, NULL
2448
2449			Success EVP_PKEY_print_params(Crypt::OpenSSL3::BIO out, Crypt::OpenSSL3::PKey pkey, int indent)
2450			C_ARGS: out, pkey, indent, NULL
2451
2452			MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::PKey::Context PREFIX = EVP_PKEY_CTX_
2453
2454
2455			Crypt::OpenSSL3::PKey::Context EVP_PKEY_CTX_new(SV* classname, Crypt::OpenSSL3::PKey pkey)
2456			C_ARGS: pkey, NULL
2457
2458			Crypt::OpenSSL3::PKey::Context EVP_PKEY_CTX_new_id(SV* classname, int id)
2459			C_ARGS: id, NULL
2460
2461			Crypt::OpenSSL3::PKey::Context EVP_PKEY_CTX_new_from_name(SV* classname, const char name, const char propquery = "")
2462			C_ARGS: NULL, name, propquery
2463
2464			Crypt::OpenSSL3::PKey::Context EVP_PKEY_CTX_new_from_pkey(SV* classname, Crypt::OpenSSL3::PKey pkey, const char *propquery = "")
2465			C_ARGS: NULL, pkey, propquery
2466
2467			Crypt::OpenSSL3::PKey::Context EVP_PKEY_CTX_dup(Crypt::OpenSSL3::PKey::Context ctx)
2468
2469			bool EVP_PKEY_CTX_set_params(Crypt::OpenSSL3::PKey::Context ctx, PARAMS(EVP_PKEY_CTX) params = NULL)
2470
2471			SV* EVP_PKEY_CTX_get_param(Crypt::OpenSSL3::PKey::Context ctx, const char* name)
2472			CODE:
2473	0	0	GENERATE_GET_PARAM(EVP_PKEY_CTX, ctx, name)
		0
		0
		0
2474			OUTPUT:
2475			RETVAL
2476
2477
2478			bool EVP_PKEY_CTX_is_a(Crypt::OpenSSL3::PKey::Context ctx, const char *keytype)
2479
2480			bool EVP_PKEY_CTX_set_signature_md(Crypt::OpenSSL3::PKey::Context ctx, Crypt::OpenSSL3::MD md)
2481
2482			void EVP_PKEY_CTX_get_signature_md(Crypt::OpenSSL3::PKey::Context ctx, OUTLIST Crypt::OpenSSL3::MD md)
2483			C_ARGS: ctx, (const EVP_MD**)&md
2484
2485			bool EVP_PKEY_CTX_set_mac_key(Crypt::OpenSSL3::PKey::Context ctx, const unsigned char *key, int length(key))
2486
2487			bool EVP_PKEY_CTX_set_group_name(Crypt::OpenSSL3::PKey::Context ctx, const char *name)
2488
2489			NO_OUTPUT bool EVP_PKEY_CTX_get_group_name(Crypt::OpenSSL3::PKey::Context ctx, OUTLIST SV* name, size_t size = 32)
2490			INIT:
2491	0		char* ptr = (char*)make_buffer(&name, size);
2492			C_ARGS: ctx, ptr, size + 1
2493			POSTCALL:
2494	0	0	if (RETVAL)
2495	0		set_buffer_length(name, strlen(ptr));
2496
2497			bool EVP_PKEY_CTX_set_kem_op(Crypt::OpenSSL3::PKey::Context ctx, const char *op)
2498
2499
2500			bool EVP_PKEY_CTX_set_rsa_padding(Crypt::OpenSSL3::PKey::Context ctx, int pad)
2501
2502			bool EVP_PKEY_CTX_get_rsa_padding(Crypt::OpenSSL3::PKey::Context ctx, OUT int pad)
2503
2504			bool EVP_PKEY_CTX_set_rsa_pss_saltlen(Crypt::OpenSSL3::PKey::Context ctx, int saltlen)
2505
2506			bool EVP_PKEY_CTX_get_rsa_pss_saltlen(Crypt::OpenSSL3::PKey::Context ctx, OUT int saltlen)
2507
2508			bool EVP_PKEY_CTX_set_rsa_keygen_bits(Crypt::OpenSSL3::PKey::Context ctx, int mbits)
2509
2510			bool EVP_PKEY_CTX_set_rsa_keygen_primes(Crypt::OpenSSL3::PKey::Context ctx, int primes)
2511
2512			bool EVP_PKEY_CTX_set_rsa_mgf1_md_name(Crypt::OpenSSL3::PKey::Context ctx, const char mdname, const char mdprops)
2513
2514			bool EVP_PKEY_CTX_set_rsa_mgf1_md(Crypt::OpenSSL3::PKey::Context ctx, Crypt::OpenSSL3::MD md)
2515
2516			bool EVP_PKEY_CTX_get_rsa_mgf1_md(Crypt::OpenSSL3::PKey::Context ctx, OUT Crypt::OpenSSL3::MD md)
2517			C_ARGS: ctx, (const EVP_MD**)&md
2518
2519			bool EVP_PKEY_CTX_get_rsa_mgf1_md_name(Crypt::OpenSSL3::PKey::Context ctx, char *name, size_t length(name))
2520
2521			bool EVP_PKEY_CTX_set_rsa_oaep_md_name(Crypt::OpenSSL3::PKey::Context ctx, const char mdname, const char mdprops)
2522
2523			bool EVP_PKEY_CTX_set_rsa_oaep_md(Crypt::OpenSSL3::PKey::Context ctx, Crypt::OpenSSL3::MD md)
2524
2525			bool EVP_PKEY_CTX_get_rsa_oaep_md(Crypt::OpenSSL3::PKey::Context ctx, OUT Crypt::OpenSSL3::MD md)
2526			C_ARGS: ctx, (const EVP_MD**)&md
2527
2528			bool EVP_PKEY_CTX_get_rsa_oaep_md_name(Crypt::OpenSSL3::PKey::Context ctx, char *name, size_t length(name))
2529
2530			bool EVP_PKEY_CTX_set_rsa_oaep_label(Crypt::OpenSSL3::PKey::Context ctx, char *label, int length(label))
2531
2532			bool EVP_PKEY_CTX_get_rsa_oaep_label(Crypt::OpenSSL3::PKey::Context ctx, OUT unsigned char *label)
2533
2534
2535			bool EVP_PKEY_CTX_set_dsa_paramgen_bits(Crypt::OpenSSL3::PKey::Context ctx, int nbits)
2536
2537			bool EVP_PKEY_CTX_set_dsa_paramgen_q_bits(Crypt::OpenSSL3::PKey::Context ctx, int qbits)
2538
2539			bool EVP_PKEY_CTX_set_dsa_paramgen_md(Crypt::OpenSSL3::PKey::Context ctx, Crypt::OpenSSL3::MD md)
2540
2541			bool EVP_PKEY_CTX_set_dsa_paramgen_md_props(Crypt::OpenSSL3::PKey::Context ctx, const char md_name, const char md_properties)
2542
2543			bool EVP_PKEY_CTX_set_dsa_paramgen_type(Crypt::OpenSSL3::PKey::Context ctx, const char *name)
2544
2545			bool EVP_PKEY_CTX_set_dsa_paramgen_gindex(Crypt::OpenSSL3::PKey::Context ctx, int gindex)
2546
2547			bool EVP_PKEY_CTX_set_dsa_paramgen_seed(Crypt::OpenSSL3::PKey::Context ctx, const unsigned char *seed, size_t length(seed))
2548
2549
2550			bool EVP_PKEY_CTX_set_dh_paramgen_prime_len(Crypt::OpenSSL3::PKey::Context ctx, int len)
2551
2552			bool EVP_PKEY_CTX_set_dh_paramgen_subprime_len(Crypt::OpenSSL3::PKey::Context ctx, int len)
2553
2554			bool EVP_PKEY_CTX_set_dh_paramgen_generator(Crypt::OpenSSL3::PKey::Context ctx, int gen)
2555
2556			bool EVP_PKEY_CTX_set_dh_paramgen_type(Crypt::OpenSSL3::PKey::Context ctx, int type)
2557
2558			bool EVP_PKEY_CTX_set_dh_pad(Crypt::OpenSSL3::PKey::Context ctx, int pad)
2559
2560			bool EVP_PKEY_CTX_set_dh_nid(Crypt::OpenSSL3::PKey::Context ctx, int nid)
2561
2562			bool EVP_PKEY_CTX_set_dh_rfc5114(Crypt::OpenSSL3::PKey::Context ctx, int rfc5114)
2563
2564			bool EVP_PKEY_CTX_set_dhx_rfc5114(Crypt::OpenSSL3::PKey::Context ctx, int rfc5114)
2565
2566			bool EVP_PKEY_CTX_set_dh_paramgen_gindex(Crypt::OpenSSL3::PKey::Context ctx, int gindex)
2567
2568			bool EVP_PKEY_CTX_set_dh_paramgen_seed(Crypt::OpenSSL3::PKey::Context ctx, const unsigned char *seed, size_t length(seed))
2569
2570			bool EVP_PKEY_CTX_set_dh_kdf_type(Crypt::OpenSSL3::PKey::Context ctx, int kdf)
2571
2572			bool EVP_PKEY_CTX_get_dh_kdf_type(Crypt::OpenSSL3::PKey::Context ctx)
2573
2574			bool EVP_PKEY_CTX_set_dh_kdf_oid(Crypt::OpenSSL3::PKey::Context ctx, Crypt::OpenSSL3::ASN1::Object oid)
2575
2576			bool EVP_PKEY_CTX_get_dh_kdf_oid(Crypt::OpenSSL3::PKey::Context ctx, OUT Crypt::OpenSSL3::ASN1::Object oid)
2577
2578			bool EVP_PKEY_CTX_set_dh_kdf_md(Crypt::OpenSSL3::PKey::Context ctx, Crypt::OpenSSL3::MD md)
2579
2580			bool EVP_PKEY_CTX_get_dh_kdf_md(Crypt::OpenSSL3::PKey::Context ctx, OUT Crypt::OpenSSL3::MD md)
2581			C_ARGS: ctx, (const EVP_MD**)&md
2582
2583			bool EVP_PKEY_CTX_set_dh_kdf_outlen(Crypt::OpenSSL3::PKey::Context ctx, int len)
2584
2585			bool EVP_PKEY_CTX_get_dh_kdf_outlen(Crypt::OpenSSL3::PKey::Context ctx, OUT int len)
2586
2587
2588			bool EVP_PKEY_CTX_set_ec_paramgen_curve_nid(Crypt::OpenSSL3::PKey::Context ctx, int nid)
2589
2590			bool EVP_PKEY_CTX_set_ec_param_enc(Crypt::OpenSSL3::PKey::Context ctx, int param_enc)
2591
2592			bool EVP_PKEY_CTX_set_ecdh_cofactor_mode(Crypt::OpenSSL3::PKey::Context ctx, int cofactor_mode)
2593
2594			bool EVP_PKEY_CTX_get_ecdh_cofactor_mode(Crypt::OpenSSL3::PKey::Context ctx)
2595
2596			bool EVP_PKEY_CTX_set_ecdh_kdf_type(Crypt::OpenSSL3::PKey::Context ctx, int kdf)
2597
2598			bool EVP_PKEY_CTX_get_ecdh_kdf_type(Crypt::OpenSSL3::PKey::Context ctx)
2599
2600			bool EVP_PKEY_CTX_set_ecdh_kdf_md(Crypt::OpenSSL3::PKey::Context ctx, Crypt::OpenSSL3::MD md)
2601
2602			bool EVP_PKEY_CTX_get_ecdh_kdf_md(Crypt::OpenSSL3::PKey::Context ctx, OUT Crypt::OpenSSL3::MD md)
2603			C_ARGS: ctx, (const EVP_MD**)&md
2604
2605			bool EVP_PKEY_CTX_set_ecdh_kdf_outlen(Crypt::OpenSSL3::PKey::Context ctx, int len)
2606
2607			bool EVP_PKEY_CTX_get_ecdh_kdf_outlen(Crypt::OpenSSL3::PKey::Context ctx, OUT int len)
2608
2609			bool EVP_PKEY_CTX_set_id(Crypt::OpenSSL3::PKey::Context ctx, const char* id, size_t length(id))
2610
2611			bool EVP_PKEY_CTX_get_id(Crypt::OpenSSL3::PKey::Context ctx, SV* id)
2612			CODE:
2613			size_t length;
2614	0		EVP_PKEY_CTX_get1_id_len(ctx, &length);
2615	0		char* ptr = grow_buffer(id, length);
2616	0		RETVAL = EVP_PKEY_CTX_get1_id(ctx, ptr);
2617	0	0	if (RETVAL)
2618	0		set_buffer_length(id, length);
2619			OUTPUT:
2620			RETVAL
2621
2622			bool EVP_PKEY_CTX_set_hkdf_mode(Crypt::OpenSSL3::PKey::Context pctx, int mode)
2623
2624			bool EVP_PKEY_CTX_set_hkdf_md(Crypt::OpenSSL3::PKey::Context pctx, Crypt::OpenSSL3::MD md)
2625
2626			bool EVP_PKEY_CTX_set_hkdf_salt(Crypt::OpenSSL3::PKey::Context pctx, unsigned char *salt, int length(salt))
2627
2628			bool EVP_PKEY_CTX_set_hkdf_key(Crypt::OpenSSL3::PKey::Context pctx, unsigned char *key, int length(key))
2629
2630			bool EVP_PKEY_CTX_add_hkdf_info(Crypt::OpenSSL3::PKey::Context pctx, unsigned char *info, int length(info))
2631
2632			#if OPENSSL_VERSION_PREREQ(3, 4)
2633			bool EVP_PKEY_CTX_set_signature(Crypt::OpenSSL3::PKey::Context pctx, const unsigned char *sig, size_t length(sig))
2634			#endif
2635
2636			int EVP_PKEY_CTX_get_keygen_info(Crypt::OpenSSL3::PKey::Context ctx, int idx)
2637
2638
2639			MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::PKey::Context PREFIX = EVP_PKEY_
2640
2641			Success EVP_PKEY_keygen_init(Crypt::OpenSSL3::PKey::Context ctx)
2642
2643			Success EVP_PKEY_paramgen_init(Crypt::OpenSSL3::PKey::Context ctx)
2644
2645			NO_OUTPUT int EVP_PKEY_generate(Crypt::OpenSSL3::PKey::Context ctx, OUTLIST Crypt::OpenSSL3::PKey ppkey)
2646			INIT:
2647	2		ppkey = NULL;
2648			POSTCALL:
2649	2	50	if (RETVAL <= 0)
2650	0		XSRETURN_UNDEF;
2651
2652			Success EVP_PKEY_encapsulate_init(Crypt::OpenSSL3::PKey::Context ctx)
2653			C_ARGS: ctx, NULL
2654
2655			void EVP_PKEY_encapsulate(Crypt::OpenSSL3::PKey::Context ctx, OUTLIST SV* wrapped_key, OUTLIST SV* gen_key)
2656			CODE:
2657			size_t wrapped_length, gen_length;
2658	1	50	if (EVP_PKEY_encapsulate(ctx, NULL, &wrapped_length, NULL, &gen_length) != 1)
2659	0		XSRETURN_EMPTY;
2660
2661	1		unsigned char* wrapped_ptr = make_buffer(&wrapped_key, wrapped_length);
2662	1		unsigned char* gen_ptr = make_buffer(&gen_key, gen_length);
2663
2664	1	50	if (EVP_PKEY_encapsulate(ctx, wrapped_ptr, &wrapped_length, gen_ptr, &gen_length)) {
2665	1		set_buffer_length(wrapped_key, wrapped_length);
2666	1		set_buffer_length(gen_key, gen_length);
2667			} else
2668	0		XSRETURN_EMPTY;
2669
2670			Success EVP_PKEY_decapsulate_init(Crypt::OpenSSL3::PKey::Context ctx)
2671			C_ARGS: ctx, NULL
2672
2673			SV* EVP_PKEY_decapsulate(Crypt::OpenSSL3::PKey::Context ctx, const unsigned char *wrapped, size_t length(wrapped))
2674			CODE:
2675			size_t unwrapped_length;
2676	1		int result = EVP_PKEY_decapsulate(ctx, NULL, &unwrapped_length, wrapped, XSauto_length_of_wrapped);
2677	1	50	if (result == 1) {
2678	1		unsigned char* unwrapped_ptr = make_buffer(&RETVAL, unwrapped_length);
2679
2680	1	50	if (EVP_PKEY_decapsulate(ctx, unwrapped_ptr, &unwrapped_length, wrapped, XSauto_length_of_wrapped) == 1)
2681	1		set_buffer_length(RETVAL, unwrapped_length);
2682			} else
2683	0		RETVAL = &PL_sv_undef;
2684			OUTPUT:
2685			RETVAL
2686
2687			#if OPENSSL_VERSION_PREREQ(3, 2)
2688			Success EVP_PKEY_auth_encapsulate_init(Crypt::OpenSSL3::PKey::Context ctx, Crypt::OpenSSL3::PKey authpriv)
2689			C_ARGS: ctx, authpriv, NULL
2690
2691			Success EVP_PKEY_auth_decapsulate_init(Crypt::OpenSSL3::PKey::Context ctx, Crypt::OpenSSL3::PKey authpub)
2692			C_ARGS: ctx, authpub, NULL
2693			#endif
2694
2695			Success EVP_PKEY_encrypt_init(Crypt::OpenSSL3::PKey::Context ctx)
2696			C_ARGS: ctx, NULL
2697
2698			SV* EVP_PKEY_encrypt(Crypt::OpenSSL3::PKey::Context ctx, const unsigned char *in, size_t length(in))
2699			CODE:
2700			size_t out_length;
2701	0		bool result = EVP_PKEY_encrypt(ctx, NULL, &out_length, in, XSauto_length_of_in);
2702	0	0	if (result == 1) {
2703	0		unsigned char* out_ptr = make_buffer(&RETVAL, out_length);
2704
2705	0		result = EVP_PKEY_encrypt(ctx, out_ptr, &out_length, in, XSauto_length_of_in);
2706	0	0	if (result == 1)
2707	0		set_buffer_length(RETVAL, out_length);
2708			} else
2709	0		RETVAL = &PL_sv_undef;
2710			OUTPUT:
2711			RETVAL
2712
2713			bool EVP_PKEY_decrypt_init(Crypt::OpenSSL3::PKey::Context ctx)
2714			C_ARGS: ctx, NULL
2715
2716			SV* EVP_PKEY_decrypt(Crypt::OpenSSL3::PKey::Context ctx, const unsigned char *in, size_t length(in))
2717			CODE:
2718			size_t out_length;
2719	0	0	if (EVP_PKEY_decrypt(ctx, NULL, &out_length, in, XSauto_length_of_in) == 1) {
2720	0		unsigned char* out_ptr = make_buffer(&RETVAL, out_length);
2721
2722	0	0	if (EVP_PKEY_decrypt(ctx, out_ptr, &out_length, in, XSauto_length_of_in) == 1)
2723	0		set_buffer_length(RETVAL, out_length);
2724			} else
2725	0		RETVAL = &PL_sv_undef;
2726			OUTPUT:
2727			RETVAL
2728
2729			bool EVP_PKEY_derive_init(Crypt::OpenSSL3::PKey::Context ctx)
2730			C_ARGS: ctx, NULL
2731
2732			bool EVP_PKEY_derive_set_peer(Crypt::OpenSSL3::PKey::Context ctx, Crypt::OpenSSL3::PKey peer, bool validate_peer = false)
2733
2734			SV* EVP_PKEY_derive(Crypt::OpenSSL3::PKey::Context ctx)
2735			CODE:
2736			size_t key_length;
2737	0	0	if (EVP_PKEY_derive(ctx, NULL, &key_length) == 1) {
2738	0		unsigned char* key_ptr = make_buffer(&RETVAL, key_length);
2739
2740	0	0	if (EVP_PKEY_derive(ctx, key_ptr, &key_length) == 1)
2741	0		set_buffer_length(RETVAL, key_length);
2742			} else
2743	0		RETVAL = &PL_sv_undef;
2744			OUTPUT:
2745			RETVAL
2746
2747			Success EVP_PKEY_sign_init(Crypt::OpenSSL3::PKey::Context ctx, Crypt::OpenSSL3::Signature type = NULL, CTX_PARAMS(EVP_SIGNATURE) params = NULL)
2748
2749			SV* EVP_PKEY_sign(Crypt::OpenSSL3::PKey::Context ctx, const unsigned char *tbs, size_t length(tbs))
2750			CODE:
2751			size_t sig_length;
2752	0	0	if (EVP_PKEY_sign(ctx, NULL, &sig_length, tbs, XSauto_length_of_tbs) == 1) {
2753	0		unsigned char* sig_ptr = make_buffer(&RETVAL, sig_length);
2754
2755	0	0	if (EVP_PKEY_sign(ctx, sig_ptr, &sig_length, tbs, XSauto_length_of_tbs) == 1)
2756	0		set_buffer_length(RETVAL, sig_length);
2757			} else
2758	0		RETVAL = &PL_sv_undef;
2759			OUTPUT:
2760			RETVAL
2761
2762			Success EVP_PKEY_verify_init(Crypt::OpenSSL3::PKey::Context ctx, Crypt::OpenSSL3::Signature type = NULL, CTX_PARAMS(EVP_SIGNATURE) params = NULL)
2763
2764			Success EVP_PKEY_verify(Crypt::OpenSSL3::PKey::Context ctx, const unsigned char sig, size_t length(sig), const unsigned char tbs, size_t length(tbs))
2765
2766			#if OPENSSL_VERSION_PREREQ(3, 4)
2767			Success EVP_PKEY_sign_message_init(Crypt::OpenSSL3::PKey::Context ctx, Crypt::OpenSSL3::Signature type = NULL, CTX_PARAMS(EVP_SIGNATURE) params = NULL)
2768
2769			Success EVP_PKEY_sign_message_update(Crypt::OpenSSL3::PKey::Context ctx, unsigned char *in, size_t length(in))
2770
2771			SV* EVP_PKEY_sign_message_final(Crypt::OpenSSL3::PKey::Context ctx)
2772			CODE:
2773			size_t sigsize;
2774			if (EVP_PKEY_sign_message_final(ctx, NULL, &sigsize) == 1) {
2775			unsigned char* ptr = make_buffer(&RETVAL, sigsize);
2776			if (EVP_PKEY_sign_message_final(ctx, ptr, &sigsize) == 1)
2777			set_buffer_length(RETVAL, sigsize);
2778			} else
2779			RETVAL = &PL_sv_undef;
2780			OUTPUT:
2781			RETVAL
2782
2783			Success EVP_PKEY_verify_message_init(Crypt::OpenSSL3::PKey::Context ctx, Crypt::OpenSSL3::Signature type = NULL, CTX_PARAMS(EVP_SIGNATURE) params = NULL)
2784
2785			Success EVP_PKEY_verify_message_update(Crypt::OpenSSL3::PKey::Context ctx, unsigned char *in, size_t length(in))
2786
2787			Success EVP_PKEY_verify_message_final(Crypt::OpenSSL3::PKey::Context ctx)
2788
2789			#endif