File Coverage

lib/Crypt/OpenSSL3.xs

Criterion	Covered	Total	%
statement	266	788	33.7
branch	55	380	14.4
condition			n/a
subroutine			n/a
pod			n/a
total	321	1168	27.4

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			#include
21			#include
22			#if OPENSSL_VERSION_PREREQ(3, 2)
23			#include
24			#endif
25
26	12		static unsigned char* S_make_buffer(pTHX_ SV** retval, size_t size) {
27	12		*retval = newSVpv("", 0);
28	12	50	char* ptr = SvGROW(*retval, size);
		100
29	12		return (unsigned char*)ptr;
30			}
31			#define make_buffer(svp, size) S_make_buffer(aTHX_ svp, size)
32
33	1		static char* S_grow_buffer(pTHX_ SV* buffer, size_t size) {
34	1	50	SvUPGRADE(buffer, SVt_PV);
35	1	50	SV_CHECK_THINKFIRST(buffer);
36	1	50	return SvGROW(buffer, size);
		50
37			}
38			#define grow_buffer(sv, size) S_grow_buffer(aTHX_ sv, size)
39
40	13		static inline void S_set_buffer_length(pTHX_ SV* buffer, ssize_t result) {
41	13		SvCUR_set(buffer, result);
42	13		SvPOK_only(buffer);
43	13		}
44			#define set_buffer_length(buffer, result) S_set_buffer_length(aTHX_ buffer, result)
45
46			#define TYPE_TYPE(c_type, xs_type) typedef c_type * Crypt__OpenSSL3__ ## xs_type;
47			#define MAGIC_TABLE(xs_type, dup, free)\
48			static const MGVTBL Crypt__OpenSSL3__ ## xs_type ## _magic = {\
49			.svt_free = free,\
50			.svt_dup = dup,\
51			};
52
53			#define TYPE_COMMON(c_type, xs_type, p_type)\
54			static inline SV* make_ ## c_type(pTHX_ void* var) {\
55			SV* result = newSV(0);\
56			const char* classname = "Crypt::OpenSSL3::" #p_type;\
57			const MGVTBL* mgvtbl = &Crypt__OpenSSL3__## xs_type ##_magic;\
58			MAGIC* magic = sv_magicext(newSVrv(result, classname), NULL, PERL_MAGIC_ext, mgvtbl, (const char*)var, 0);\
59			magic->mg_flags \|= MGf_DUP;\
60			return result;\
61			}\
62			static inline c_type* get_ ## c_type (pTHX_ SV* value) {\
63			if (!SvROK(value))\
64			return NULL;\
65			MAGIC* magic = mg_findext(SvRV(value), PERL_MAGIC_ext, &Crypt__OpenSSL3__## xs_type ##_magic);\
66			return magic ? (c_type*)magic->mg_ptr : NULL;\
67			}
68
69			#define DUPLICATING_TYPE(c_type, xs_type, p_type)\
70			TYPE_TYPE(c_type, xs_type)\
71			static int c_type ## _magic_dup(pTHX_ MAGIC* mg, CLONE_PARAMS* params) {\
72			PERL_UNUSED_VAR(params);\
73			mg->mg_ptr = (char)c_type ## _dup((c_type)mg->mg_ptr);\
74			return 0;\
75			}\
76			static int c_type ## _magic_free(pTHX_ SV* sv, MAGIC* mg) {\
77			PERL_UNUSED_VAR(sv);\
78			c_type ## _free((c_type*)mg->mg_ptr);\
79			return 0;\
80			}\
81			MAGIC_TABLE(xs_type, c_type ## _magic_dup, c_type ## _magic_free)\
82			TYPE_COMMON(c_type, xs_type, p_type)
83
84			#define COUNTING_TYPE(c_type, xs_type, p_type)\
85			typedef c_type * Crypt__OpenSSL3__ ## xs_type;\
86			static int c_type ## _magic_dup(pTHX_ MAGIC* mg, CLONE_PARAMS* params) {\
87			PERL_UNUSED_VAR(params);\
88			c_type ## _up_ref((c_type*)mg->mg_ptr);\
89			return 0;\
90			}\
91			static int c_type ## _magic_free(pTHX_ SV* sv, MAGIC* mg) {\
92			PERL_UNUSED_VAR(sv);\
93			c_type ## _free((c_type*)mg->mg_ptr);\
94			return 0;\
95			}\
96			MAGIC_TABLE(xs_type, c_type ## _magic_dup, c_type ## _magic_free)\
97			TYPE_COMMON(c_type, xs_type, p_type)
98
99			#define SIMPLE_TYPE(c_type, xs_type, p_type, modifier)\
100			TYPE_TYPE(modifier c_type, xs_type)\
101			MAGIC_TABLE(xs_type, NULL, NULL)\
102			TYPE_COMMON(c_type, xs_type, p_type)
103
104			#define STACK_TYPE(c_prefix, xs_type)\
105			typedef STACK_OF(c_prefix) * Crypt__OpenSSL3__ ## xs_type ## __Stack;\
106			static int c_prefix ## __Stack_magic_dup(pTHX_ MAGIC* mg, CLONE_PARAMS* params) {\
107			PERL_UNUSED_VAR(params);\
108			mg->mg_ptr = (char)sk_ ## c_prefix ## _dup((STACK_OF(c_prefix))mg->mg_ptr);\
109			return 0;\
110			}\
111			static int c_prefix ## __Stack_magic_free(pTHX_ SV* sv, MAGIC* mg) {\
112			PERL_UNUSED_VAR(sv);\
113			sk_ ## c_prefix ## _free((STACK_OF(c_prefix)*)mg->mg_ptr);\
114			return 0;\
115			}\
116			static const MGVTBL Crypt__OpenSSL3__ ## xs_type ## __Stack_magic = {\
117			.svt_dup = c_prefix ## __Stack_magic_dup,\
118			.svt_free = c_prefix ## __Stack_magic_free,\
119			};
120
121			#if !OPENSSL_VERSION_PREREQ(3, 2)
122	0		static EVP_MD_CTX EVP_MD_CTX_dup(const EVP_MD_CTX in) {
123	0		EVP_MD_CTX* result = EVP_MD_CTX_new();
124	0		EVP_MD_CTX_copy(result, in);
125	0		return result;
126			}
127
128	0		static EVP_CIPHER_CTX EVP_CIPHER_CTX_dup(const EVP_CIPHER_CTX in) {
129	0		EVP_CIPHER_CTX* result = EVP_CIPHER_CTX_new();
130	0		EVP_CIPHER_CTX_copy(result, in);
131	0		return result;
132			}
133			#define EVP_RAND_CTX_up_ref(ctx) NULL
134			#endif
135
136			typedef unsigned long Crypt__OpenSSL3__Error;
137	0		COUNTING_TYPE(EVP_RAND, Random, Random)
	0
	0
	0
138	0		COUNTING_TYPE(EVP_RAND_CTX, Random__Context, Random::Context)
	0
	0
139	249	0	COUNTING_TYPE(EVP_CIPHER, Cipher, Cipher)
	0	0
	124
	125
	0
140	2		DUPLICATING_TYPE(EVP_CIPHER_CTX, Cipher__Context, Cipher::Context)
	2
	0
141	45		COUNTING_TYPE(EVP_MD, MD, MD)
	22
	23
	0
142	3		DUPLICATING_TYPE(EVP_MD_CTX, MD__Context, MD::Context)
	3
	0
143	19		COUNTING_TYPE(EVP_MAC, MAC, MAC)
	9
	10
	0
144	1		DUPLICATING_TYPE(EVP_MAC_CTX, MAC__Context, MAC::Context)
	1
	0
145	25		COUNTING_TYPE(EVP_KDF, KDF, KDF)
	12
	13
	0
146	1		DUPLICATING_TYPE(EVP_KDF_CTX, KDF__Context, KDF::Context)
	1
	0
147	0		COUNTING_TYPE(EVP_SIGNATURE, Signature, Signature)
	0
	0
	0
148	2		DUPLICATING_TYPE(EVP_PKEY, PKey, PKey)
	2
	0
149	4		DUPLICATING_TYPE(EVP_PKEY_CTX, PKey__Context, PKey::Context)
	4
	0
150
151			typedef BIGNUM BN;
152	6	50	DUPLICATING_TYPE(BN, BigNum, BigNum);
	6	0
	0
	0
	0
153			#define BN_CTX_dup(old) BN_CTX_new()
154	0		DUPLICATING_TYPE(BN_CTX, BigNum__Context, BigNum::Context)
	0
	0
155
156			typedef int Crypt__OpenSSL3__NID;
157	0		SIMPLE_TYPE(ASN1_OBJECT, ASN1__Object, ASN1::Object, const)
158	0		DUPLICATING_TYPE(ASN1_INTEGER, ASN1__Integer, ASN1::Integer)
	0
	0
159			#define ASN1_ENUMERATED_dup ASN1_INTEGER_dup
160	0		DUPLICATING_TYPE(ASN1_ENUMERATED, ASN1__Enumerated, ASN1::Enumerated)
	0
	0
161	0		DUPLICATING_TYPE(ASN1_STRING, ASN1__String, ASN1::String)
	0
	0
	0
162	0		DUPLICATING_TYPE(ASN1_TIME, ASN1__Time, ASN1::Time)
	0
	0
163	0		DUPLICATING_TYPE(ASN1_GENERALIZEDTIME, ASN1__Time__Generalized, ASN1::Time::Generalized)
	0
	0
164	0		DUPLICATING_TYPE(ASN1_UTCTIME, ASN1__Time__UTC, ASN1::Time::UTC)
	0
	0
165	0		DUPLICATING_TYPE(X509, X509, X509)
	0
	0
166	0		STACK_TYPE(X509, X509)
	0
	0
167	0		COUNTING_TYPE(X509_STORE, X509__Store, X509::Store)
	0
	0
168	0		DUPLICATING_TYPE(X509_NAME, X509__Name, X509::Name)
	0
	0
	0
169	0		DUPLICATING_TYPE(X509_NAME_ENTRY, X509__Name__Entry, X509::Name::Entry)
	0
	0
170	0		DUPLICATING_TYPE(X509_REQ, X509__Request, X509::Request)
	0
	0
171	0		DUPLICATING_TYPE(X509_ALGOR, X509__Algorithm, X509::Algorithm)
	0
	0
172	0		DUPLICATING_TYPE(X509_EXTENSION, X509__Extension, X509::Extension)
	0
	0
173	0		DUPLICATING_TYPE(X509_ATTRIBUTE, X509__Attribute, X509::Attribute)
	0
	0
174			SIMPLE_TYPE(X509_VERIFY_PARAM, X509__VerifyParam, X509::VerifyParam, )
175	0		DUPLICATING_TYPE(GENERAL_NAME, X509__GeneralName, X509::GeneralName)
	0
	0
176			typedef long Crypt__OpenSSL3__X509__VerifyResult;
177	0		DUPLICATING_TYPE(PKCS7, PKCS7, PKCS7)
	0
	0
178
179	0		DUPLICATING_TYPE(TS_REQ, Timestamp__Request, Timestamp::Request)
	0
	0
180	0		DUPLICATING_TYPE(TS_RESP, Timestamp__Response, Timestamp::Respone)
	0
	0
181	0		DUPLICATING_TYPE(TS_MSG_IMPRINT, Timestamp__Imprint, Timestamp::Imprint)
	0
	0
182	0		DUPLICATING_TYPE(TS_TST_INFO, Timestamp__TokenInfo, Timestamp::TokenInfo)
	0
	0
183	0		DUPLICATING_TYPE(TS_STATUS_INFO, Timestamp__StatusInfo, Timestamp::StatusInfo)
	0
	0
184	0		DUPLICATING_TYPE(TS_ACCURACY, Timestamp__Accuracy, Timestamp::Accuracy)
	0
	0
185			#define TS_VERIFY_CTX_dup(ctx) NULL
186	0		DUPLICATING_TYPE(TS_VERIFY_CTX, Timestamp__Verifier, Timestamp::Verifier)
	0
	0
187
188	2		COUNTING_TYPE(BIO, BIO, BIO)
	2
	0
189			#if OPENSSL_VERSION_PREREQ(3, 2)
190			DUPLICATING_TYPE(BIO_ADDR, BIO__Address, BIO::Address)
191			typedef BIO_POLL_DESCRIPTOR* Crypt__OpenSSL3__BIO__PollDescriptor;
192			#endif
193
194			SIMPLE_TYPE(SSL_METHOD, SSL__Method, SSL::Method, const)
195	1		COUNTING_TYPE(SSL_CTX, SSL__Context, SSL::Context)
	1
	0
196	2		COUNTING_TYPE(SSL, SSL, SSL)
	2
	0
197	0		DUPLICATING_TYPE(SSL_SESSION, SSL__Session, SSL::Session)
	0
	0
198			SIMPLE_TYPE(SSL_CIPHER, SSL__Cipher, SSL::Context, const)
199
200			#if OPENSSL_VERSION_PREREQ(3, 2)
201			typedef struct HPKE {
202			OSSL_HPKE_CTX* context;
203			OSSL_HPKE_SUITE suite;
204			} HPKE;
205
206			#define HPKE_dup(hpke) NULL
207
208			static void HPKE_free(HPKE* hpke) {
209			OSSL_HPKE_CTX_free(hpke->context);
210			Safefree(hpke);
211			}
212
213			DUPLICATING_TYPE(HPKE, HPKE__Context, HPKE::Context)
214			typedef OSSL_HPKE_SUITE* Crypt__OpenSSL3__HPKE;
215			#endif
216
217			#define PARAMS(a) OSSL_PARAM*
218			#define CTX_PARAMS(a) OSSL_PARAM*
219
220			#undef OPENSSL_VERSION_TEXT
221			#define OPENSSL_VERSION_TEXT OPENSSL_VERSION
222
223			#define BIO_new_mem() BIO_new(BIO_s_mem())
224			#define BIO_POLL_DESCRIPTOR_new(class) safecalloc(1, sizeof(BIO_POLL_DESCRIPTOR))
225			#define BIO_POLL_DESCRIPTOR_type(desc) ((desc)->type)
226			#define BIO_POLL_DESCRIPTOR_fd(desc) ((desc)->value.fd)
227
228			#define BN_generate_prime BN_generate_prime_ex2
229
230			#define OBJ_get_data OBJ_get0_data
231			#define OBJ_from_nid OBJ_nid2obj
232			#define OBJ_from_text OBJ_txt2obj
233			#define OBJ_to_nid OBJ_obj2nid
234	0		SV* S_OBJ_to_text(pTHX_ const ASN1_OBJECT* object, bool no_name) {
235	0		SV* result = &PL_sv_undef;
236	0		int buf_len = OBJ_obj2txt(NULL, 0, object, no_name);
237	0	0	if (buf_len > 0) {
238	0		unsigned char* ptr = make_buffer(&result, buf_len);
239	0	0	if (OBJ_obj2txt((char*)ptr, buf_len, object, no_name) > 0)
240	0		set_buffer_length(result, buf_len);
241			}
242	0		return result;
243			}
244			#define OBJ_to_text(object, no_name) S_OBJ_to_text(aTHX_ object, no_name)
245			#define ASN1_INTEGER_get_BN(ai) ASN1_INTEGER_to_BN(ai, NULL)
246			#define ASN1_INTEGER_set_BN(ai, bn) BN_to_ASN1_INTEGER(bn, ai)
247			#define ASN1_INTEGER_set_buffer ASN1_STRING_set
248			#define ASN1_ENUMERATED_set_BN(ai, bn) BN_to_ASN1_ENUMERATED(bn, ai)
249			#define ASN1_ENUMERATED_get_BN(ai) ASN1_ENUMERATED_to_BN(ai, NULL)
250			#define ASN1_TIME_cmp_time ASN1_TIME_cmp_time_t
251
252			#define GENERAL_NAME_type(gn) (gn->type)
253
254			#define X509_read_der d2i_X509_bio
255			#define X509_write_der i2d_X509_bio
256			#define X509_read_pem PEM_read_bio_X509
257			#define X509_write_pem PEM_write_bio_X509
258			#define X509_get_tbs_sigalg(c) (X509_ALGOR*)X509_get0_tbs_sigalg(c)
259			#define X509_get_signature X509_get0_signature
260			#define X509_get_subject_key_id(c) (ASN1_OCTET_STRING*)X509_get0_subject_key_id(c)
261			#define X509_get_authority_issuer(c) (GENERAL_NAME*)X509_get0_authority_issuer(c)
262			#define X509_get_authority_key_id(c) (ASN1_OCTET_STRING*)X509_get0_authority_key_id(c)
263			#define X509_get_authority_serial(c) (ASN1_INTEGER*)X509_get0_authority_serial(c)
264			#define X509_set_notAfter X509_set1_notAfter
265			#define X509_set_notBefore X509_set1_notBefore
266			#define X509_get_distinguishing_id(c) ASN1_OCTET_STRING_dup(X509_get0_distinguishing_id(c))
267			#define X509_set_distinguishing_id X509_set0_distinguishing_id
268			#define X509_get_ext(c, loc) X509_EXTENSION_dup(X509_get_ext(c, loc))
269			#define X509_EXTENSION_get_object(e) X509_EXTENSION_get_object(e)
270			#define X509_EXTENSION_get_data(e) ASN1_OCTET_STRING_dup(X509_EXTENSION_get_data(e))
271			#define X509_ATTRIBUTE_get_data X509_ATTRIBUTE_get0_data
272			#define X509_ATTRIBUTE_set_data X509_ATTRIBUTE_set1_data
273			#define X509_ATTRIBUTE_get_object X509_ATTRIBUTE_get0_object
274			#define X509_ATTRIBUTE_set_object X509_ATTRIBUTE_set1_object
275			#define X509_NAME_get_entry(n, loc) X509_NAME_ENTRY_dup(X509_NAME_get_entry(n, loc))
276			#undef X509_NAME_hash
277			#define X509_NAME_hash X509_NAME_hash_ex
278			#define X509_NAME_print X509_NAME_print_ex
279			#define GENERAL_NAME_new_from_x509_name GENERAL_NAME_set1_X509_NAME
280			#define X509_STORE_load_file X509_STORE_load_file_ex
281			#define X509_STORE_load_store X509_STORE_load_store_ex
282			#define X509_ALGOR_get X509_ALGOR_get0
283			#define X509_ALGOR_set X509_ALGOR_set0
284			#define X509_verify_cert_error_code(value) value
285			#define X509_verify_cert_ok(value) (value == X509_V_OK)
286			#define X509_VERIFY_PARAM_add_policy X509_VERIFY_PARAM_add0_policy
287			#define X509_VERIFY_PARAM_get_host X509_VERIFY_PARAM_get0_host
288			#define X509_VERIFY_PARAM_set_host X509_VERIFY_PARAM_set1_host
289			#define X509_VERIFY_PARAM_add_host X509_VERIFY_PARAM_add1_host
290			#define X509_VERIFY_PARAM_get_peername X509_VERIFY_PARAM_get0_peername
291			#define X509_VERIFY_PARAM_get_email X509_VERIFY_PARAM_get0_email
292			#define X509_VERIFY_PARAM_set_email X509_VERIFY_PARAM_set1_email
293			#define X509_VERIFY_PARAM_get_ip_asc X509_VERIFY_PARAM_get1_ip_asc
294			#define X509_VERIFY_PARAM_set_ip X509_VERIFY_PARAM_set1_ip
295			#define X509_VERIFY_PARAM_set_ip_asc X509_VERIFY_PARAM_set1_ip_asc
296			#define X509_REQ_new X509_REQ_new_ex
297			#define X509_REQ_read_der d2i_X509_REQ_bio
298			#define X509_REQ_write_der i2d_X509_REQ_bio
299			#define X509_REQ_read_pem PEM_read_bio_X509_REQ
300			#define X509_REQ_write_pem PEM_write_bio_X509_REQ
301			#define X509_REQ_add_attr X509_REQ_add1_attr
302			#define X509_REQ_add_attr_by_NID X509_REQ_add1_attr_by_NID
303			#define X509_REQ_add_attr_by_OBJ X509_REQ_add1_attr_by_OBJ
304			#define X509_REQ_add_attr_by_txt X509_REQ_add1_attr_by_txt
305			#define X509_REQ_get_X509_pubkey X509_REQ_get_X509_PUBKEY
306			#define X509_REQ_get_distinguishing_id(c) ASN1_OCTET_STRING_dup(X509_REQ_get0_distinguishing_id(c))
307			#define X509_REQ_set_distinguishing_id X509_REQ_set0_distinguishing_id
308			#define X509_REQ_get_signature X509_REQ_get0_signature
309			#define X509_REQ_set_signature X509_REQ_set0_signature
310			#define X509_REQ_set_signature_algo X509_REQ_set1_signature_algo
311			#define X509_REQ_verify X509_REQ_verify_ex
312
313			#define PKCS7_new PKCS7_new_ex
314			#define PKCS7_read_pem PEM_read_bio_PKCS7
315			#define PKCS7_write_pem PEM_write_bio_PKCS7
316			#define PKCS7_read_der d2i_PKCS7_bio
317			#define PKCS7_write_der i2d_PKCS7_bio
318			#define PKCS7_sign PKCS7_sign_ex
319			#define PKCS7_get_signers PKCS7_get0_signers
320			#define PKCS7_encrypt PKCS7_encrypt_ex
321
322			#define TS_REQ_print(t, b) TS_REQ_print_bio(b, t)
323			#define TS_REQ_read_der d2i_TS_REQ_bio
324			#define TS_REQ_write_der i2d_TS_REQ_bio
325			#define TS_REQ_get_nonce(req) ASN1_INTEGER_dup(TS_REQ_get_nonce(req))
326			#define TS_TST_INFO_print(t, b) TS_TST_INFO_print_bio(b, t)
327			#define TS_TST_INFO_read_der d2i_TS_TST_INFO_bio
328			#define TS_TST_INFO_write_der i2d_TS_TST_INFO_bio
329			#define TS_RESP_print(t, b) TS_RESP_print_bio(b, t)
330			#define TS_RESP_read_der d2i_TS_RESP_bio
331			#define TS_RESP_write_der i2d_TS_RESP_bio
332			#define TS_MSG_IMPRINT_print(t, b) TS_MSG_IMPRINT_print_bio(b, t)
333			#define TS_MSG_IMPRINT_read_der d2i_TS_MSG_IMPRINT_bio
334			#define TS_MSG_IMPRINT_write_der i2d_TS_MSG_IMPRINT_bio
335			#define TS_TST_INFO_get_serial(tst) ASN1_INTEGER_dup(TS_TST_INFO_get_serial(tst))
336			#define TS_TST_INFO_get_time(tst) ASN1_GENERALIZEDTIME_dup(TS_TST_INFO_get_time(tst))
337			#define TS_TST_INFO_get_nonce(tst) ASN1_INTEGER_dup(TS_TST_INFO_get_nonce(tst))
338			#define TS_STATUS_INFO_get_status(status) ASN1_INTEGER_dup(TS_STATUS_INFO_get0_status(status))
339			#define TS_STATUS_INFO_get_failure_info(status) ASN1_INTEGER_dup(TS_STATUS_INFO_get0_failure_info(status))
340			#define TS_ACCURACY_get_seconds(status) ASN1_INTEGER_dup(TS_ACCURACY_get_seconds(status))
341			#define TS_ACCURACY_get_millis(status) ASN1_INTEGER_dup(TS_ACCURACY_get_millis(status))
342			#define TS_ACCURACY_get_micros(status) ASN1_INTEGER_dup(TS_ACCURACY_get_micros(status))
343			#define TS_VERIFY_CTX_init_from_request(ctx, req) TS_REQ_to_TS_VERIFY_CTX(req, ctx)
344			#if OPENSSL_VERSION_PREREQ(3, 4)
345			#define TS_VERIFY_CTX_set_data TS_VERIFY_CTX_set0_data
346			#define TS_VERIFY_CTX_set_imprint TS_VERIFY_CTX_set0_imprint
347			#define TS_VERIFY_CTX_set_store TS_VERIFY_CTX_set0_store
348			#define TS_VERIFY_CTX_set_certs TS_VERIFY_CTX_set0_certs
349			#endif
350			#define TS_VERIFY_CTX_verify_response TS_RESP_verify_response
351
352			#define SSL_Method_TLS TLS_method
353			#define SSL_Method_TLS_server TLS_server_method
354			#define SSL_Method_TLS_client TLS_client_method
355
356			#define SSL_Method_DTLS DTLS_method
357			#define SSL_Method_DTLS_server DTLS_server_method
358			#define SSL_Method_DTLS_client DTLS_client_method
359
360			#define SSL_Method_QUIC_client OSSL_QUIC_client_method
361			#define SSL_Method_QUIC_client_thread OSSL_QUIC_client_thread_method
362			#define SSL_Method_QUIC_server OSSL_QUIC_server_method
363
364			#define SSL_CTX_get_param SSL_CTX_get0_param
365			#define SSL_CTX_set_param SSL_CTX_set1_param
366
367			#define SSL_set_host SSL_set1_host
368			#define SSL_set_dnsname SSL_set1_dnsname
369			#define SSL_set_ipaddr SSL_set1_ipaddr
370			#define SSL_set_rbio SSL_set0_rbio
371			#define SSL_set_wbio SSL_set0_wbio
372			#define SSL_get_context SSL_get_SSL_CTX
373			#define SSL_get_alpn_selected SSL_get0_alpn_selected
374			#define SSL_get_connection SSL_get0_connection
375			#define SSL_get_listener SSL_get0_listener
376			#define SSL_get_domain SSL_get0_domain
377			#define SSL_set_initial_peer_addr SSL_set1_initial_peer_addr
378			#define SSL_get_param SSL_get0_param
379			#define SSL_set_param SSL_set1_param
380			#if !OPENSSL_VERSION_PREREQ(3, 2)
381			#define SSL_is_tls(s) (!SSL_is_dtls(s))
382			#define SSL_is_quic(s) FALSE
383			#endif
384
385			#define SSL_SESSION_read_der d2i_SSL_SESSION_bio
386			#define SSL_SESSION_write_der i2d_SSL_SESSION_bio
387			#define SSL_SESSION_get_peer SSL_SESSION_get0_peer
388			#define SSL_SESSION_get_alpn_selected SSL_SESSION_get0_alpn_selected
389			#define SSL_SESSION_get_cipher SSL_SESSION_get0_cipher
390			#define SSL_SESSION_get_hostname SSL_SESSION_get0_hostname
391			#define SSL_SESSION_get_id_context SSL_SESSION_get0_id_context
392			#define SSL_SESSION_get_ticket SSL_SESSION_get0_ticket
393			#define SSL_SESSION_set_alpn_selected SSL_SESSION_set1_alpn_selected
394			#define SSL_SESSION_set_hostname SSL_SESSION_set1_hostname
395			#define SSL_SESSION_set_id SSL_SESSION_set1_id
396			#define SSL_SESSION_set_id_context SSL_SESSION_set1_id_context
397			#if !OPENSSL_VERSION_PREREQ(3,2)
398			#define SSL_get_event_timeout(s, tv, inf) DTLSv1_get_timeout(s, tv)
399			#define SSL_handle_events DTLSv1_handle_timeout
400			#endif
401			#if OPENSSL_VERSION_PREREQ(3, 3)
402			#define SSL_SESSION_get_time SSL_SESSION_get_time_ex
403			#define SSL_SESSION_set_time SSL_SESSION_set_time_ex
404			#endif
405
406			#define NID_create OBJ_create
407			#define NID_from_long_name OBJ_ln2nid
408			#define NID_from_short_name OBJ_sn2nid
409			#define NID_from_text OBJ_txt2nid
410			#define NID_get_long_name OBJ_nid2ln
411			#define NID_get_short_name OBJ_nid2sn
412			#define NID_to_object OBJ_nid2obj
413			#define NID_eq(left, right) (left == right)
414			#define NID_raw(nid) nid
415			#define NID_is_undef(nid) (nid == NID_undef)
416
417			#define SSL_CIPHER_get_handshake_digest(c) (EVP_MD*)SSL_CIPHER_get_handshake_digest(c)
418
419			#define RAND_get_primary RAND_get0_primary
420			#define RAND_get_public RAND_get0_public
421			#define RAND_get_private RAND_get0_private
422			#define RAND_set_public RAND_set0_public
423			#define RAND_set_private RAND_set0_private
424			#define EVP_RAND_get_name EVP_RAND_get0_name
425			#define EVP_RAND_get_description EVP_RAND_get0_description
426			#define EVP_RAND_CTX_get_rand EVP_RAND_CTX_get0_rand
427			#define EVP_CIPHER_get_name EVP_CIPHER_get0_name
428			#define EVP_CIPHER_get_description EVP_CIPHER_get0_description
429			#undef EVP_CIPHER_CTX_init
430			#define EVP_CIPHER_CTX_init EVP_CipherInit_ex2
431			#define EVP_CIPHER_CTX_update EVP_CipherUpdate
432			#define EVP_CIPHER_CTX_final EVP_CipherFinal_ex
433			#define EVP_CIPHER_CTX_set_aead_ivlen(ctx, length) EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_IVLEN, length, NULL)
434			#define EVP_CIPHER_CTX_get_aead_tag(ctx, ptr, length) EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_GET_TAG, length, ptr)
435			#define EVP_CIPHER_CTX_set_aead_tag(ctx, ptr, length) EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_TAG, length, ptr)
436			#define EVP_CIPHER_CTX_get_name EVP_CIPHER_CTX_get0_name
437			#define EVP_CIPHER_CTX_get_cipher EVP_CIPHER_CTX_get1_cipher
438
439			#define EVP_MD_digest EVP_Digest
440			#define EVP_MD_get_name EVP_MD_get0_name
441			#define EVP_MD_get_description EVP_MD_get0_description
442			#undef EVP_MD_CTX_init
443			#define EVP_MD_CTX_get_md EVP_MD_CTX_get1_md
444			#define EVP_MD_CTX_get_name EVP_MD_CTX_get0_name
445			#define EVP_MD_CTX_init EVP_DigestInit_ex2
446			#define EVP_MD_CTX_update EVP_DigestUpdate
447			#define EVP_MD_CTX_final EVP_DigestFinal_ex
448			#define EVP_MD_CTX_final_xof EVP_DigestFinalXOF
449			#define EVP_MD_CTX_squeeze EVP_DigestSqueeze
450			#define EVP_MD_CTX_sign_init EVP_DigestSignInit
451			#define EVP_MD_CTX_sign_init_ex EVP_DigestSignInit_ex
452			#define EVP_MD_CTX_sign_update EVP_DigestSignUpdate
453			#define EVP_MD_CTX_sign_final EVP_DigestSignFinal
454			#define EVP_MD_CTX_sign EVP_DigestSign
455			#define EVP_MD_CTX_verify_init EVP_DigestVerifyInit
456			#define EVP_MD_CTX_verify_update EVP_DigestVerifyUpdate
457			#define EVP_MD_CTX_verify_final EVP_DigestVerifyFinal
458			#define EVP_MD_CTX_verify EVP_DigestVerify
459
460			#define EVP_MAC_get_name EVP_MAC_get0_name
461			#define EVP_MAC_get_description EVP_MAC_get0_description
462			#define EVP_MAC_CTX_get_mac EVP_MAC_CTX_get0_mac
463			#define EVP_MAC_CTX_get_name EVP_MAC_CTX_get0_name
464
465			#define EVP_KDF_get_name EVP_KDF_get0_name
466			#define EVP_KDF_get_description EVP_KDF_get0_description
467			#define EVP_KDF_CTX_get_name EVP_KDF_CTX_get0_name
468			#define EVP_KDF_CTX_kdf(ctx) (EVP_KDF*)EVP_KDF_CTX_kdf(ctx)
469
470			#define EVP_SIGNATURE_get_name EVP_SIGNATURE_get0_name
471			#define EVP_SIGNATURE_get_description EVP_SIGNATURE_get0_description
472
473			#define EVP_PKEY_read_pem_private_key PEM_read_bio_PrivateKey_ex
474			#define EVP_PKEY_write_pem_private_key PEM_write_bio_PrivateKey_ex
475			#define EVP_PKEY_read_pem_public_key PEM_read_bio_PUBKEY_ex
476			#define EVP_PKEY_write_pem_public_key PEM_write_bio_PUBKEY_ex
477			#define EVP_PKEY_read_der_private_key d2i_PrivateKey_ex_bio
478			#define EVP_PKEY_write_der_private_key i2d_PrivateKey_bio
479			#if !OPENSSL_VERSION_PREREQ(3, 2)
480			#define d2i_PUBKEY_ex_bio(bio, ptr, lib, propq) d2i_PUBKEY_bio(bio, ptr)
481			#endif
482			#define EVP_PKEY_read_der_public_key d2i_PUBKEY_ex_bio
483			#define EVP_PKEY_write_der_public_key i2d_PUBKEY_bio
484			#define EVP_PKEY_new_raw_private_key EVP_PKEY_new_raw_private_key_ex
485			#define EVP_PKEY_new_raw_public_key EVP_PKEY_new_raw_public_key_ex
486			#define EVP_PKEY_get_description EVP_PKEY_get0_description
487			#define EVP_PKEY_get_type_name EVP_PKEY_get0_type_name
488			#define EVP_PKEY_get_encoded_public_key EVP_PKEY_get1_encoded_public_key
489			#define EVP_PKEY_set_encoded_public_key EVP_PKEY_set1_encoded_public_key
490			#define EVP_PKEY_encrypt_init EVP_PKEY_encrypt_init_ex
491			#define EVP_PKEY_decrypt_init EVP_PKEY_decrypt_init_ex
492			#define EVP_PKEY_derive_init EVP_PKEY_derive_init_ex
493			#define EVP_PKEY_derive_set_peer EVP_PKEY_derive_set_peer_ex
494
495			#if !OPENSSL_VERSION_PREREQ(3, 4)
496	0		static int EVP_PKEY_sign_init_ex2(EVP_PKEY_CTX ctx, EVP_SIGNATURE algo, const OSSL_PARAM params[]) {
497	0	0	if (algo)
498	0		return FALSE;
499	0		return EVP_PKEY_sign_init_ex(ctx, params);
500			}
501
502	0		static int EVP_PKEY_verify_init_ex2(EVP_PKEY_CTX ctx, EVP_SIGNATURE algo, const OSSL_PARAM params[]) {
503	0	0	if (algo)
504	0		return FALSE;
505	0		return EVP_PKEY_verify_init_ex(ctx, params);
506			}
507			#endif
508			#define EVP_PKEY_sign_init EVP_PKEY_sign_init_ex2
509			#define EVP_PKEY_verify_init EVP_PKEY_verify_init_ex2
510
511
512			#if OPENSSL_VERSION_PREREQ(3, 2)
513			#define OSSL_HPKE_CTX_set_authpriv OSSL_HPKE_CTX_set1_authpriv
514			#define OSSL_HPKE_CTX_set_authpub OSSL_HPKE_CTX_set1_authpub
515			#define OSSL_HPKE_CTX_set_psk OSSL_HPKE_CTX_set1_psk
516			#define OSSL_HPKE_CTX_set_ikme OSSL_HPKE_CTX_set1_ikme
517			#define OSSL_HPKE_decapsulate OSSL_HPKE_decap
518			#define OSSL_HPKE_check OSSL_HPKE_suite_check
519			#define OSSL_HPKE_kem_id(suite) (suite)->kem_id
520			#define OSSL_HPKE_kdf_id(suite) (suite)->kdf_id
521			#define OSSL_HPKE_aead_id(suite) (suite)->aead_id
522			#endif
523
524			#define CONSTANT2(PREFIX, VALUE) newCONSTSUB(stash, #VALUE, newSVuv(PREFIX##VALUE))
525
526	7		static OSSL_PARAM* S_params_for(pTHX_ const OSSL_PARAM* settable, SV* input) {
527	7	50	if (!SvROK(input) \|\| SvTYPE(SvRV(input)) != SVt_PVHV)
		50
528	0		return NULL;
529
530	7		OSSL_PARAM_BLD* builder = OSSL_PARAM_BLD_new();
531	7		HV* hash = (HV*)SvRV(input);
532
533	7		hv_iterinit(hash);
534			char* name;
535			I32 name_len;
536			SV* sv;
537
538	19	100	while (sv = hv_iternextsv(hash, &name, &name_len)) {
539	12		const OSSL_PARAM* found = OSSL_PARAM_locate_const(settable, name);
540
541	12	100	if (found) {
542			const BIGNUM* big;
543	11	50	if (found->data_type == OSSL_PARAM_INTEGER) {
544	0	0	if (big = get_BN(aTHX_ sv))
545	0		OSSL_PARAM_BLD_push_BN(builder, found->key, big);
546			else
547	0		OSSL_PARAM_BLD_push_int64(builder, found->key, SvIV(sv));
548	11	100	} else if (found->data_type == OSSL_PARAM_UNSIGNED_INTEGER) {
549	6	50	if (big = get_BN(aTHX_ sv))
550	0		OSSL_PARAM_BLD_push_BN(builder, found->key, big);
551			else
552	6		OSSL_PARAM_BLD_push_uint64(builder, found->key, SvUV(sv));
553	5	50	} else if (found->data_type == OSSL_PARAM_REAL) {
554	0		OSSL_PARAM_BLD_push_double(builder, found->key, SvNV(sv));
555	5	100	} else if (found->data_type == OSSL_PARAM_UTF8_STRING) {
556			STRLEN length;
557	4		const char* ptr = SvPVutf8(sv, length);
558	4		OSSL_PARAM_BLD_push_utf8_string(builder, found->key, ptr, length);
559	1	50	} else if (found->data_type == OSSL_PARAM_OCTET_STRING) {
560			STRLEN length;
561	1		const char* ptr = SvPVbyte(sv, length);
562	1		OSSL_PARAM_BLD_push_octet_string(builder, found->key, ptr, length);
563			}
564			}
565			}
566
567	7		OSSL_PARAM* result = OSSL_PARAM_BLD_to_param(builder);
568	7		OSSL_PARAM_BLD_free(builder);
569	7		SAVEDESTRUCTOR(OSSL_PARAM_free, result);
570	7		return result;
571			}
572			#define params_for(settable, sv) S_params_for(aTHX_ settable, sv)
573
574	1		static SV* S_make_param_scalar(pTHX_ OSSL_PARAM* iter) {
575	1	50	if (iter->data_type == OSSL_PARAM_INTEGER) {
576	0	0	if (iter->data_size == 0)
577	0		return newSViv(0);
578	0	0	else if (iter->data_size <= IVSIZE) {
579			int64_t value;
580	0		OSSL_PARAM_get_int64(iter, &value);
581	0		return newSViv(value);
582			} else {
583	0		BIGNUM* value = NULL;
584	0		OSSL_PARAM_get_BN(iter, &value);
585	0		return make_BN(aTHX_ value);
586			}
587			}
588	1	50	else if (iter->data_type == OSSL_PARAM_UNSIGNED_INTEGER) {
589	1	50	if (iter->data_size == 0)
590	0		return newSVuv(0);
591	1	50	else if (iter->data_size <= UVSIZE) {
592	1		uint64_t value = 0;
593	1		OSSL_PARAM_get_uint64(iter, &value);
594	1		return newSVuv(value);
595			} else {
596	0		BIGNUM* value = NULL;
597	0		OSSL_PARAM_get_BN(iter, &value);
598	0		return make_BN(aTHX_ value);
599			}
600			}
601	0	0	else if (iter->data_type == OSSL_PARAM_REAL) {
602			double value;
603	0		OSSL_PARAM_get_double(iter, &value);
604	0		return newSVnv(value);
605			}
606	0	0	else if (iter->data_type == OSSL_PARAM_UTF8_STRING) {
607	0		return newSVpvn_utf8((const char*)iter->data, iter->data_size, 1);
608			}
609	0	0	else if (iter->data_type == OSSL_PARAM_OCTET_STRING) {
610	0		return newSVpvn((const char*)iter->data, iter->data_size);
611			}
612
613	0		return NULL;
614			}
615			#define make_param_scalar(params) S_make_param_scalar(aTHX_ params)
616
617			#define GENERATE_GET_PARAM(prefix, arg, name)\
618			RETVAL = &PL_sv_undef;\
619			const OSSL_PARAM* description = OSSL_PARAM_locate_const(prefix ## _gettable_params(arg), name);\
620			if (description) {\
621			OSSL_PARAM params[] = {\
622			OSSL_PARAM_DEFN(description->key, description->data_type, NULL, SIZE_MAX),\
623			OSSL_PARAM_END,\
624			};\
625			if (prefix ## _get_params(arg, params)) {\
626			if (OSSL_PARAM_modified(params)) {\
627			params->data = OPENSSL_zalloc(params->return_size);\
628			params->data_size = params->return_size;\
629			}\
630			if (prefix ## _get_params(arg, params))\
631			RETVAL = make_param_scalar(params);\
632			}\
633			}
634
635			#ifdef MULTIPLICITY
636			#define iTHX aTHX
637			#else
638			#define iTHX NULL
639			#endif
640
641	0		static void EVP_name_callback(const char* name, void* vdata) {
642			dTHXa((PerlInterpreter*)vdata);
643	0		dSP;
644	0	0	mXPUSHp(name, strlen(name));
645	0		PUTBACK;
646	0		}
647
648			#define DEFINE_PROVIDED_CALLBACK(c_type)\
649			static inline void c_type ## _provided_callback(c_type* provided, void* vdata) {\
650			dTHXa((PerlInterpreter*)vdata);\
651			c_type ## _up_ref(provided);\
652			SV* object = make_ ## c_type(aTHX_ provided);\
653			dSP;\
654			mXPUSHs(object);\
655			PUTBACK;\
656			}
657	0	0	DEFINE_PROVIDED_CALLBACK(EVP_RAND)
658	124	50	DEFINE_PROVIDED_CALLBACK(EVP_CIPHER)
659	22	50	DEFINE_PROVIDED_CALLBACK(EVP_MD)
660	9	50	DEFINE_PROVIDED_CALLBACK(EVP_MAC)
661	12	50	DEFINE_PROVIDED_CALLBACK(EVP_KDF)
662	0	0	DEFINE_PROVIDED_CALLBACK(EVP_SIGNATURE)
663
664			typedef int Bool;
665			typedef int Success;
666			typedef int PrintRet;
667			#define undef &PL_sv_undef
668
669			#define CLONE_SKIP(...) 1
670
671			// This will force byte semantics on all strings
672			// This should come as the last thing in the C section of this file
673			#undef SvPV
674			#define SvPV(sv, len) SvPVbyte(sv, len)
675			#undef SvPV_nolen
676			#define SvPV_nolen(sv) SvPVbyte_nolen(sv)
677
678			MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3 PREFIX = OpenSSL_
679
680			REQUIRE: 3.60
681
682			PROTOTYPES: DISABLE
683
684			TYPEMAP: <
685			const unsigned char* T_PV
686			Bool T_BOOL
687			struct timeval T_TIMEVAL
688			int64_t T_IV
689			uint32_t T_UV
690			uint64_t T_UV
691			Success T_SUCCESS
692			PrintRet T_PRINT
693
694			Crypt::OpenSSL3::Random T_MAGICEXT
695			Crypt::OpenSSL3::Random::Context T_MAGICEXT
696			Crypt::OpenSSL3::Cipher T_MAGICEXT
697			Crypt::OpenSSL3::Cipher::Context T_MAGICEXT
698			Crypt::OpenSSL3::MD T_MAGICEXT
699			Crypt::OpenSSL3::MD::Context T_MAGICEXT
700			Crypt::OpenSSL3::MAC T_MAGICEXT
701			Crypt::OpenSSL3::MAC::Context T_MAGICEXT
702			Crypt::OpenSSL3::KDF T_MAGICEXT
703			Crypt::OpenSSL3::KDF::Context T_MAGICEXT
704			Crypt::OpenSSL3::Signature T_MAGICEXT
705			Crypt::OpenSSL3::PKey T_MAGICEXT
706			Crypt::OpenSSL3::PKey::Context T_MAGICEXT
707
708			Crypt::OpenSSL3::BIO T_MAGICEXT
709			Crypt::OpenSSL3::BIO::Address T_MAGICEXT
710			Crypt::OpenSSL3::BIO::PollDescriptor T_MAGICBUF
711			Crypt::OpenSSL3::Error T_INTOBJ
712
713			Crypt::OpenSSL3::BigNum T_MAGICEXT
714			Crypt::OpenSSL3::BigNum::Context T_MAGICEXT
715
716			Crypt::OpenSSL3::ASN1::Object T_MAGICEXT
717			Crypt::OpenSSL3::ASN1::Integer T_MAGICEXT
718			Crypt::OpenSSL3::ASN1::Enumerated T_MAGICEXT
719			Crypt::OpenSSL3::ASN1::String T_MAGICEXT
720			Crypt::OpenSSL3::ASN1::String::UTF8 T_MAGICEXT
721			Crypt::OpenSSL3::ASN1::Time T_MAGICEXT
722			Crypt::OpenSSL3::ASN1::Time::Generalized T_MAGICEXT
723			Crypt::OpenSSL3::ASN1::Time::UTC T_MAGICEXT
724
725			Crypt::OpenSSL3::X509 T_MAGICEXT
726			Crypt::OpenSSL3::X509::Stack T_MAGICEXT
727			Crypt::OpenSSL3::X509::Store T_MAGICEXT
728			Crypt::OpenSSL3::X509::Name T_MAGICEXT
729			Crypt::OpenSSL3::X509::Name::Entry T_MAGICEXT
730			Crypt::OpenSSL3::X509::Algorithm T_MAGICEXT
731			Crypt::OpenSSL3::X509::VerifyResult T_INTOBJ
732			Crypt::OpenSSL3::X509::GeneralName T_MAGICEXT
733			Crypt::OpenSSL3::X509::Extension T_MAGICEXT
734			Crypt::OpenSSL3::X509::Attribute T_MAGICEXT
735			Crypt::OpenSSL3::X509::VerifyParam T_MAGICEXT
736			Crypt::OpenSSL3::X509::Request T_MAGICEXT
737
738			Crypt::OpenSSL3::PKCS7 T_MAGICEXT
739
740			Crypt::OpenSSL3::Timestamp::Request T_MAGICEXT
741			Crypt::OpenSSL3::Timestamp::Response T_MAGICEXT
742			Crypt::OpenSSL3::Timestamp::Imprint T_MAGICEXT
743			Crypt::OpenSSL3::Timestamp::TokenInfo T_MAGICEXT
744			Crypt::OpenSSL3::Timestamp::StatusInfo T_MAGICEXT
745			Crypt::OpenSSL3::Timestamp::Accuracy T_MAGICEXT
746			Crypt::OpenSSL3::Timestamp::Verifier T_MAGICEXT
747
748			Crypt::OpenSSL3::SSL::Method T_MAGICEXT
749			Crypt::OpenSSL3::SSL::Context T_MAGICEXT
750			Crypt::OpenSSL3::SSL T_MAGICEXT
751			Crypt::OpenSSL3::SSL::Session T_MAGICEXT
752			Crypt::OpenSSL3::SSL::Cipher T_MAGICEXT
753			Crypt::OpenSSL3::NID T_INTOBJ
754
755			Crypt::OpenSSL3::HPKE T_MAGICBUF
756			Crypt::OpenSSL3::HPKE::Context T_MAGICEXT
757
758			PARAMS(EVP_RAND_CTX) T_PARAMS
759			PARAMS(EVP_CIPHER_CTX) T_PARAMS
760			CTX_PARAMS(EVP_CIPHER) T_CTX_PARAMS
761			PARAMS(EVP_MD_CTX) T_PARAMS
762			CTX_PARAMS(EVP_MD) T_CTX_PARAMS
763			PARAMS(EVP_MAC_CTX) T_PARAMS
764			PARAMS(EVP_KDF_CTX) T_PARAMS
765			PARAMS(EVP_PKEY) T_PARAMS
766			PARAMS(EVP_PKEY_CTX) T_PARAMS
767			CTX_PARAMS(EVP_SIGNATURE) T_CTX_PARAMS
768
769			INPUT
770			T_PARAMS
771			const OSSL_PARAM* settable = ${ (my $settable = $type) =~ s/ PARAMS $ (\w+) $ /$1_settable_params(ctx)/x; \$settable };
772			$var = params_for(settable, $arg);
773
774			T_CTX_PARAMS
775			const OSSL_PARAM* settable = ${ (my $settable = $type) =~ s/ CTX_PARAMS $ (\w+) $ /$1_settable_ctx_params(type)/x; \$settable };
776			$var = params_for(settable, $arg);
777
778			OUTPUT
779			T_TIMEVAL
780			sv_setnv($arg, $var.tv_sec + $var.tv_usec / 1000000.0);
781			T_SUCCESS
782			${"$var" eq "RETVAL" ? \"$arg = $var < 0 ? &PL_sv_undef : boolSV($var);" : \"sv_setsv($arg, $var < 0 ? &PL_sv_undef : boolSV($var));"}
783			T_PRINT
784			${"$var" eq "RETVAL" ? \"$arg = $var < 0 ? &PL_sv_undef : newSViv($var);" : \"if ($var < 0) sv_setsv($arg, &PL_sv_undef); else sv_setiv($arg, $var);"}
785			T_PV
786			sv_setpv((SV)$arg, (const char)$var);
787			END
788
789			BOOT:
790			{
791	60		HV* stash = gv_stashpvs("Crypt::OpenSSL3::", GV_ADD \| GV_ADDMULTI);
792	60		CONSTANT2(OPENSSL_, VERSION_STRING);
793	60		CONSTANT2(OPENSSL_, VERSION_TEXT);
794	60		CONSTANT2(OPENSSL_, FULL_VERSION_STRING);
795	60		CONSTANT2(OPENSSL_, CFLAGS);
796	60		CONSTANT2(OPENSSL_, BUILT_ON);
797	60		CONSTANT2(OPENSSL_, PLATFORM);
798	60		CONSTANT2(OPENSSL_, DIR);
799	60		CONSTANT2(OPENSSL_, ENGINES_DIR);
800	60		CONSTANT2(OPENSSL_, MODULES_DIR);
801	60		CONSTANT2(OPENSSL_, CPU_INFO);
802	60		CONSTANT2(OPENSSL_, INFO_CONFIG_DIR);
803	60		CONSTANT2(OPENSSL_, INFO_ENGINES_DIR);
804	60		CONSTANT2(OPENSSL_, INFO_MODULES_DIR);
805	60		CONSTANT2(OPENSSL_, INFO_DSO_EXTENSION);
806	60		CONSTANT2(OPENSSL_, INFO_DIR_FILENAME_SEPARATOR);
807	60		CONSTANT2(OPENSSL_, INFO_LIST_SEPARATOR);
808	60		CONSTANT2(OPENSSL_, INFO_CPU_SETTINGS);
809			#if OPENSSL_VERSION_PREREQ(3, 4)
810			CONSTANT2(OPENSSL_, WINCTX);
811			CONSTANT2(OPENSSL_, INFO_WINDOWS_CONTEXT);
812			#endif
813			}
814
815			const char *OpenSSL_version(int t = OPENSSL_VERSION_STRING)
816
817			unsigned long OpenSSL_version_num()
818
819			MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3 PREFIX = OPENSSL_
820
821			unsigned int OPENSSL_version_major()
822
823			unsigned int OPENSSL_version_minor()
824
825			unsigned int OPENSSL_version_patch()
826
827			const char *OPENSSL_version_pre_release()
828
829			const char *OPENSSL_version_build_metadata()
830
831			const char *OPENSSL_info(int t)
832
833			MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3 PREFIX = ERR_
834
835			Crypt::OpenSSL3::Error ERR_get_error()
836
837			Crypt::OpenSSL3::Error ERR_peek_error()
838
839			void ERR_clear_error()
840
841			MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::Error PREFIX = ERR_
842
843			SV* ERR_error_string(unsigned long e, size_t length = 64)
844			CODE:
845	0		char* ptr = (char*)make_buffer(&RETVAL, length);
846	0		ERR_error_string_n(e, ptr, length);
847	0		set_buffer_length(RETVAL, strlen(ptr));
848			OUTPUT: RETVAL
849
850			MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::BIO PREFIX = BIO_
851
852			Crypt::OpenSSL3::BIO BIO_new_file(classname, const char filename, const char mode)
853			C_ARGS: filename, mode
854
855			Crypt::OpenSSL3::BIO BIO_new_fd(class, int fd, bool close_flag = FALSE)
856			INTERFACE: BIO_new_fd BIO_new_socket BIO_new_dgram
857			C_ARGS: fd, close_flag
858
859			NO_OUTPUT int BIO_new_bio_pair(classname, OUTLIST Crypt::OpenSSL3::BIO bio1, size_t writebuf1, OUTLIST Crypt::OpenSSL3::BIO bio2, size_t writebuf2);
860			C_ARGS: &bio1, writebuf1, &bio2, writebuf2
861			POSTCALL:
862	1	50	if (!RETVAL)
863	0		XSRETURN_EMPTY;
864
865			Crypt::OpenSSL3::BIO BIO_new_mem(class)
866			C_ARGS:
867
868			bool BIO_reset(Crypt::OpenSSL3::BIO b)
869
870			int BIO_seek(Crypt::OpenSSL3::BIO b, int ofs)
871
872			int BIO_tell(Crypt::OpenSSL3::BIO b)
873
874			bool BIO_flush(Crypt::OpenSSL3::BIO b)
875
876			bool BIO_eof(Crypt::OpenSSL3::BIO b)
877
878			bool BIO_set_close(Crypt::OpenSSL3::BIO b, bool flag)
879
880			bool BIO_get_close(Crypt::OpenSSL3::BIO b)
881
882			int BIO_pending(Crypt::OpenSSL3::BIO b)
883
884			int BIO_wpending(Crypt::OpenSSL3::BIO b)
885
886			size_t BIO_ctrl_pending(Crypt::OpenSSL3::BIO b)
887
888			size_t BIO_ctrl_wpending(Crypt::OpenSSL3::BIO b)
889
890			NO_OUTPUT int BIO_read(Crypt::OpenSSL3::BIO b, OUTLIST SV* out, int size)
891			INTERFACE: BIO_read BIO_gets BIO_get_line
892			INIT:
893	0		unsigned char* ptr = make_buffer(&out, size);
894			C_ARGS: b, ptr, size
895			POSTCALL:
896	0	0	if (RETVAL >= 0)
897	0		set_buffer_length(out, RETVAL);
898
899			int BIO_write(Crypt::OpenSSL3::BIO b, const char *data, int length(data))
900
901			bool BIO_get_ktls_send(Crypt::OpenSSL3::BIO b)
902
903			bool BIO_get_ktls_recv(Crypt::OpenSSL3::BIO b)
904
905			#if OPENSSL_VERSION_PREREQ(3, 2)
906			bool BIO_get_rpoll_descriptor(Crypt::OpenSSL3::BIO b, Crypt::OpenSSL3::BIO::PollDescriptor desc)
907
908			bool BIO_get_wpoll_descriptor(Crypt::OpenSSL3::BIO b, Crypt::OpenSSL3::BIO::PollDescriptor desc)
909			#endif
910
911
912			MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::BIO::Address PREFIX = BIO_ADDR_
913
914			#if OPENSSL_VERSION_PREREQ(3, 2)
915
916			Crypt::OpenSSL3::BIO::Address BIO_ADDR_new()
917
918			bool BIO_ADDR_copy(Crypt::OpenSSL3::BIO::Address dst, Crypt::OpenSSL3::BIO::Address src)
919
920			Crypt::OpenSSL3::BIO::Address BIO_ADDR_dup(Crypt::OpenSSL3::BIO::Address ap)
921
922			void BIO_ADDR_clear(Crypt::OpenSSL3::BIO::Address ap)
923
924			bool BIO_ADDR_rawmake(Crypt::OpenSSL3::BIO::Address ap, int family, const char *where, size_t length(where), unsigned short port)
925
926			int BIO_ADDR_family(Crypt::OpenSSL3::BIO::Address ap)
927
928			SV* BIO_ADDR_rawaddress(Crypt::OpenSSL3::BIO::Address ap)
929			CODE:
930			size_t length = 0;
931			if (BIO_ADDR_rawaddress(ap, NULL, &length)) {
932			unsigned char* ptr = make_buffer(&RETVAL, length);
933			if (BIO_ADDR_rawaddress(ap, ptr, &length))
934			set_buffer_length(RETVAL, length);
935			} else
936			RETVAL = &PL_sv_undef;
937			OUTPUT: RETVAL
938
939			unsigned short BIO_ADDR_rawport(Crypt::OpenSSL3::BIO::Address ap)
940
941			char *BIO_ADDR_hostname_string(Crypt::OpenSSL3::BIO::Address ap, int numeric)
942			INTERFACE:
943			BIO_ADDR_hostname_string BIO_ADDR_service_string BIO_ADDR_path_string
944			CLEANUP:
945			OPENSSL_free(RETVAL);
946
947			#endif
948
949			MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::BIO::PollDescriptor PREFIX = BIO_POLL_DESCRIPTOR_
950			BOOT:
951			{
952			#if OPENSSL_VERSION_PREREQ(3, 2)
953			HV* stash = gv_stashpvs("Crypt::OpenSSL3::BIO::PollDescriptor", GV_ADD \| GV_ADDMULTI);
954			CONSTANT2(BIO_POLL_DESCRIPTOR_, TYPE_NONE);
955			CONSTANT2(BIO_POLL_DESCRIPTOR_, TYPE_SOCK_FD);
956			CONSTANT2(BIO_POLL_DESCRIPTOR_, CUSTOM_START);
957			#endif
958			}
959
960			#if OPENSSL_VERSION_PREREQ(3, 2)
961			Crypt::OpenSSL3::BIO::PollDescriptor BIO_POLL_DESCRIPTOR_new(class)
962
963			int BIO_POLL_DESCRIPTOR_type(Crypt::OpenSSL3::BIO::PollDescriptor desc)
964
965			int BIO_POLL_DESCRIPTOR_fd(Crypt::OpenSSL3::BIO::PollDescriptor desc)
966			#endif
967
968			MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::BigNum PREFIX = BN_
969
970			BOOT:
971			{
972	60		HV* stash = gv_stashpvs("Crypt::OpenSSL3::BigNum", GV_ADD \| GV_ADDMULTI);
973	60		CONSTANT2(BN_, RAND_TOP_ANY);
974	60		CONSTANT2(BN_, RAND_TOP_ONE);
975	60		CONSTANT2(BN_, RAND_TOP_TWO);
976
977	60		CONSTANT2(BN_, RAND_BOTTOM_ANY);
978	60		CONSTANT2(BN_, RAND_BOTTOM_ODD);
979			}
980
981
982			Crypt::OpenSSL3::BigNum BN_new(classname)
983			INTERFACE: BN_new BN_secure_new
984			C_ARGS:
985
986			Crypt::OpenSSL3::BigNum BN_dup(Crypt::OpenSSL3::BigNum self)
987
988			bool BN_copy(Crypt::OpenSSL3::BigNum self, Crypt::OpenSSL3::BigNum other)
989
990			void BN_clear(Crypt::OpenSSL3::BigNum a)
991
992			bool BN_add(Crypt::OpenSSL3::BigNum r, Crypt::OpenSSL3::BigNum a, Crypt::OpenSSL3::BigNum b)
993
994			bool BN_sub(Crypt::OpenSSL3::BigNum r, Crypt::OpenSSL3::BigNum a, Crypt::OpenSSL3::BigNum b)
995
996			bool BN_mul(Crypt::OpenSSL3::BigNum r, Crypt::OpenSSL3::BigNum a, Crypt::OpenSSL3::BigNum b, Crypt::OpenSSL3::BigNum::Context ctx)
997
998			bool BN_sqr(Crypt::OpenSSL3::BigNum r, Crypt::OpenSSL3::BigNum a, Crypt::OpenSSL3::BigNum::Context ctx)
999
1000			bool BN_div(Crypt::OpenSSL3::BigNum dv, Crypt::OpenSSL3::BigNum rem, Crypt::OpenSSL3::BigNum a, Crypt::OpenSSL3::BigNum d, Crypt::OpenSSL3::BigNum::Context ctx)
1001
1002			bool BN_mod(Crypt::OpenSSL3::BigNum rem, Crypt::OpenSSL3::BigNum a, Crypt::OpenSSL3::BigNum m, Crypt::OpenSSL3::BigNum::Context ctx)
1003
1004			bool BN_nnmod(Crypt::OpenSSL3::BigNum r, Crypt::OpenSSL3::BigNum a, Crypt::OpenSSL3::BigNum m, Crypt::OpenSSL3::BigNum::Context ctx)
1005
1006			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)
1007
1008			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)
1009
1010			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)
1011
1012			bool BN_mod_sqr(Crypt::OpenSSL3::BigNum r, Crypt::OpenSSL3::BigNum a, Crypt::OpenSSL3::BigNum m, Crypt::OpenSSL3::BigNum::Context ctx)
1013
1014			bool BN_mod_sqrt(Crypt::OpenSSL3::BigNum in, Crypt::OpenSSL3::BigNum a, Crypt::OpenSSL3::BigNum p, Crypt::OpenSSL3::BigNum::Context ctx)
1015
1016			bool BN_exp(Crypt::OpenSSL3::BigNum r, Crypt::OpenSSL3::BigNum a, Crypt::OpenSSL3::BigNum p, Crypt::OpenSSL3::BigNum::Context ctx)
1017
1018			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)
1019
1020			bool BN_gcd(Crypt::OpenSSL3::BigNum r, Crypt::OpenSSL3::BigNum a, Crypt::OpenSSL3::BigNum b, Crypt::OpenSSL3::BigNum::Context ctx)
1021
1022			int BN_num_bytes(Crypt::OpenSSL3::BigNum a)
1023
1024			int BN_num_bits(Crypt::OpenSSL3::BigNum a)
1025
1026			NO_OUTPUT int BN_bn2bin(Crypt::OpenSSL3::BigNum a, OUTLIST SV* out)
1027			INIT:
1028	0		unsigned char* ptr = make_buffer(&out, BN_num_bytes(a));
1029			C_ARGS: a, ptr
1030			POSTCALL:
1031	0		set_buffer_length(out, RETVAL);
1032
1033			NO_OUTPUT int BN_bn2binpad(Crypt::OpenSSL3::BigNum a, OUTLIST SV* out, int tolen = BN_num_bytes(a))
1034			INTERFACE: BN_bn2binpad BN_bn2lebinpad BN_bn2nativepad
1035			INIT:
1036	0		unsigned char* ptr = make_buffer(&out, tolen);
1037			C_ARGS: a, ptr, tolen
1038			POSTCALL:
1039	0	0	if (RETVAL >= 0)
1040	0		set_buffer_length(out, RETVAL);
1041
1042			Crypt::OpenSSL3::BigNum BN_bin2bn(const unsigned char *s, int length(s))
1043			INTERFACE: BN_bin2bn BN_lebin2bn BN_native2bn
1044			C_ARGS: s, XSauto_length_of_s, NULL
1045
1046			NO_OUTPUT int BN_bn2lebinpad(Crypt::OpenSSL3::BigNum a, OUTLIST SV* out, int tolen)
1047			INTERFACE: BN_bn2lebinpad BN_bn2nativepad
1048			INIT:
1049	0		unsigned char* ptr = make_buffer(&out, tolen);
1050			C_ARGS: a, ptr, tolen
1051			POSTCALL:
1052	0	0	if (RETVAL >= 0)
1053	0		set_buffer_length(out, RETVAL);
1054
1055			#if OPENSSL_VERSION_PREREQ(3, 2)
1056			NO_OUTPUT int BN_signed_bn2lebin(Crypt::OpenSSL3::BigNum a, OUTLIST SV* out, int tolen = BN_num_bytes(a))
1057			INTERFACE: BN_signed_bn2bin BN_signed_bn2lebin BN_signed_bn2native
1058			INIT:
1059			unsigned char* ptr = make_buffer(&out, tolen);
1060			C_ARGS: a, ptr, tolen
1061			POSTCALL:
1062			if (RETVAL >= 0)
1063			set_buffer_length(out, RETVAL);
1064
1065			Crypt::OpenSSL3::BigNum BN_signed_bin2bn(const unsigned char *s, int length(s))
1066			INTERFACE: BN_signed_bin2bn BN_signed_lebin2bn BN_signed_native2bn
1067			C_ARGS: s, XSauto_length_of_s, NULL
1068
1069			#endif
1070
1071			char *BN_bn2hex(Crypt::OpenSSL3::BigNum a)
1072			INTERFACE: BN_bn2hex BN_bn2dec
1073			CLEANUP:
1074	0		OPENSSL_free(RETVAL);
1075
1076			NO_OUTPUT int BN_hex2bn(OUTLIST Crypt::OpenSSL3::BigNum a, const char *str)
1077			INIT:
1078	0		a = NULL;
1079			INTERFACE: BN_hex2bn BN_dec2bn
1080			C_ARGS: &a, str
1081			POSTCALL:
1082	0	0	if (!RETVAL)
1083	0		XSRETURN_UNDEF;
1084
1085			bool BN_print(Crypt::OpenSSL3::BIO fp, Crypt::OpenSSL3::BigNum a)
1086
1087
1088			NO_OUTPUT int BN_bn2mpi(Crypt::OpenSSL3::BigNum a, OUTLIST SV* out)
1089			INIT:
1090	0		unsigned char* ptr = make_buffer(&out, BN_bn2mpi(a, NULL));
1091			C_ARGS: a, ptr
1092			POSTCALL:
1093	0		set_buffer_length(out, RETVAL);
1094
1095			Crypt::OpenSSL3::BigNum BN_mpi2bn(unsigned char *s, int len)
1096			C_ARGS: s, len, NULL
1097
1098			bool BN_check_prime(Crypt::OpenSSL3::BigNum p, Crypt::OpenSSL3::BigNum::Context ctx)
1099			C_ARGS: p, ctx, NULL
1100
1101			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)
1102			C_ARGS: ret, bits, safe, add, rem, NULL, ctx
1103
1104			bool BN_set_word(Crypt::OpenSSL3::BigNum a, UV w)
1105
1106			UV BN_get_word(Crypt::OpenSSL3::BigNum a)
1107
1108			bool BN_add_word(Crypt::OpenSSL3::BigNum a, UV w)
1109
1110			bool BN_sub_word(Crypt::OpenSSL3::BigNum a, UV w)
1111
1112			bool BN_mul_word(Crypt::OpenSSL3::BigNum a, UV w)
1113
1114			UV BN_div_word(Crypt::OpenSSL3::BigNum a, UV w)
1115
1116			UV BN_mod_word(Crypt::OpenSSL3::BigNum a, UV w)
1117
1118			int BN_cmp(Crypt::OpenSSL3::BigNum a, Crypt::OpenSSL3::BigNum b)
1119
1120			int BN_ucmp(Crypt::OpenSSL3::BigNum a, Crypt::OpenSSL3::BigNum b)
1121
1122			bool BN_is_zero(Crypt::OpenSSL3::BigNum a)
1123
1124			bool BN_is_one(Crypt::OpenSSL3::BigNum a)
1125
1126			bool BN_is_word(Crypt::OpenSSL3::BigNum a, UV w)
1127
1128			bool BN_abs_is_word(Crypt::OpenSSL3::BigNum a, UV w)
1129
1130			bool BN_is_odd(Crypt::OpenSSL3::BigNum a)
1131
1132			#if OPENSSL_VERSION_PREREQ(3, 2)
1133			bool BN_are_coprime(Crypt::OpenSSL3::BigNum a, Crypt::OpenSSL3::BigNum b, Crypt::OpenSSL3::BigNum::Context ctx);
1134			#endif
1135
1136			bool BN_clear_bit(Crypt::OpenSSL3::BigNum a, int n)
1137
1138			bool BN_is_bit_set(Crypt::OpenSSL3::BigNum a, int n)
1139
1140			bool BN_mask_bits(Crypt::OpenSSL3::BigNum a, int n)
1141
1142			bool BN_lshift(Crypt::OpenSSL3::BigNum r, Crypt::OpenSSL3::BigNum a, int n)
1143
1144			bool BN_lshift1(Crypt::OpenSSL3::BigNum r, Crypt::OpenSSL3::BigNum a)
1145
1146			bool BN_rshift(Crypt::OpenSSL3::BigNum r, Crypt::OpenSSL3::BigNum a, int n)
1147
1148			bool BN_rshift1(Crypt::OpenSSL3::BigNum r, Crypt::OpenSSL3::BigNum a)
1149
1150			bool BN_rand_ex(Crypt::OpenSSL3::BigNum rnd, int bits, int top, int bottom, unsigned int strength, Crypt::OpenSSL3::BigNum::Context ctx)
1151
1152			bool BN_rand(Crypt::OpenSSL3::BigNum rnd, int bits, int top, int bottom)
1153
1154
1155			MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::BigNum::Context PREFIX = BN_CTX_
1156
1157			Crypt::OpenSSL3::BigNum::Context BN_CTX_new(classname)
1158			INTERFACE: BN_CTX_new BN_CTX_secure_new
1159			C_ARGS:
1160
1161
1162			MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::ASN
1163
1164			BOOT:
1165			{
1166	60		HV* stash = gv_stashpvs("Crypt::OpenSSL3::ASN1", GV_ADD \| GV_ADDMULTI);
1167	60		CONSTANT2(V_ASN1_, EOC);
1168	60		CONSTANT2(V_ASN1_, BOOLEAN);
1169	60		CONSTANT2(V_ASN1_, INTEGER);
1170	60		CONSTANT2(V_ASN1_, BIT_STRING);
1171	60		CONSTANT2(V_ASN1_, OCTET_STRING);
1172	60		CONSTANT2(V_ASN1_, NULL);
1173	60		CONSTANT2(V_ASN1_, OBJECT);
1174	60		CONSTANT2(V_ASN1_, OBJECT_DESCRIPTOR);
1175	60		CONSTANT2(V_ASN1_, EXTERNAL);
1176	60		CONSTANT2(V_ASN1_, REAL);
1177	60		CONSTANT2(V_ASN1_, ENUMERATED);
1178	60		CONSTANT2(V_ASN1_, UTF8STRING);
1179	60		CONSTANT2(V_ASN1_, SEQUENCE);
1180	60		CONSTANT2(V_ASN1_, SET);
1181	60		CONSTANT2(V_ASN1_, NUMERICSTRING);
1182	60		CONSTANT2(V_ASN1_, PRINTABLESTRING);
1183	60		CONSTANT2(V_ASN1_, T61STRING);
1184	60		CONSTANT2(V_ASN1_, TELETEXSTRING);
1185	60		CONSTANT2(V_ASN1_, VIDEOTEXSTRING);
1186	60		CONSTANT2(V_ASN1_, IA5STRING);
1187	60		CONSTANT2(V_ASN1_, UTCTIME);
1188	60		CONSTANT2(V_ASN1_, GENERALIZEDTIME);
1189	60		CONSTANT2(V_ASN1_, GRAPHICSTRING);
1190	60		CONSTANT2(V_ASN1_, ISO64STRING);
1191	60		CONSTANT2(V_ASN1_, VISIBLESTRING);
1192	60		CONSTANT2(V_ASN1_, GENERALSTRING);
1193	60		CONSTANT2(V_ASN1_, UNIVERSALSTRING);
1194	60		CONSTANT2(V_ASN1_, BMPSTRING);
1195			}
1196
1197
1198			MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::ASN1::Object PREFIX = OBJ_
1199
1200			Crypt::OpenSSL3::ASN1::Object OBJ_from_text(const char *s, bool no_name = FALSE)
1201
1202			Crypt::OpenSSL3::ASN1::Object OBJ_from_nid(Crypt::OpenSSL3::NID n)
1203
1204			int OBJ_cmp(Crypt::OpenSSL3::ASN1::Object a, Crypt::OpenSSL3::ASN1::Object b)
1205
1206			Crypt::OpenSSL3::NID OBJ_to_nid(Crypt::OpenSSL3::ASN1::Object o)
1207
1208			size_t OBJ_length(Crypt::OpenSSL3::ASN1::Object obj)
1209
1210			const unsigned char *OBJ_get_data(Crypt::OpenSSL3::ASN1::Object obj)
1211
1212			SV* OBJ_to_text(Crypt::OpenSSL3::ASN1::Object a, bool no_name = FALSE)
1213
1214			MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::ASN1::Integer PREFIX = ASN1_INTEGER_
1215
1216			Crypt::OpenSSL3::ASN1::Integer ASN1_INTEGER_new()
1217			C_ARGS:
1218
1219			NO_OUTPUT int ASN1_INTEGER_get_int64(Crypt::OpenSSL3::ASN1::Integer a, OUTLIST int64_t pr)
1220			C_ARGS: &pr, a
1221			POSTCALL:
1222	0	0	if (!RETVAL)
1223	0		XSRETURN_UNDEF;
1224
1225			bool ASN1_INTEGER_set_int64(Crypt::OpenSSL3::ASN1::Integer a, int64_t r)
1226
1227			NO_OUTPUT int ASN1_INTEGER_get_uint64(Crypt::OpenSSL3::ASN1::Integer a, OUTLIST uint64_t pr)
1228			C_ARGS: &pr, a
1229			POSTCALL:
1230	0	0	if (!RETVAL)
1231	0		XSRETURN_UNDEF;
1232
1233			bool ASN1_INTEGER_set_uint64(Crypt::OpenSSL3::ASN1::Integer a, uint64_t r)
1234
1235			Crypt::OpenSSL3::BigNum ASN1_INTEGER_get_BN(Crypt::OpenSSL3::ASN1::Integer ai)
1236
1237			bool ASN1_INTEGER_set_BN(Crypt::OpenSSL3::ASN1::Integer ai, Crypt::OpenSSL3::BigNum bn)
1238
1239			bool ASN1_INTEGER_set_buffer(Crypt::OpenSSL3::ASN1::String str, const char *data, int length(data))
1240
1241			MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::ASN1::Enumerated PREFIX = ASN1_ENUMERATED_
1242
1243			Crypt::OpenSSL3::ASN1::Enumerated ASN1_ENUMERATED_new()
1244			C_ARGS:
1245
1246			NO_OUTPUT int ASN1_ENUMERATED_get_int64(Crypt::OpenSSL3::ASN1::Enumerated a, OUTLIST int64_t pr)
1247			C_ARGS: &pr, a
1248			POSTCALL:
1249	0	0	if (!RETVAL)
1250	0		XSRETURN_UNDEF;
1251
1252			bool ASN1_ENUMERATED_set_int64(Crypt::OpenSSL3::ASN1::Enumerated a, int64_t r)
1253
1254			bool ASN1_ENUMERATED_set_BN(Crypt::OpenSSL3::ASN1::Integer ai, Crypt::OpenSSL3::BigNum bn)
1255
1256			Crypt::OpenSSL3::BigNum ASN1_ENUMERATED_get_BN(Crypt::OpenSSL3::ASN1::Enumerated ai)
1257
1258			MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::ASN1::String PREFIX = ASN1_STRING_
1259
1260			BOOT:
1261			{
1262	60		HV* stash = gv_stashpvs("Crypt::OpenSSL3::ASN1::String", GV_ADD \| GV_ADDMULTI);
1263	60		CONSTANT2(ASN1_STR, FLGS_ESC_2253);
1264	60		CONSTANT2(ASN1_STR, FLGS_ESC_CTRL);
1265	60		CONSTANT2(ASN1_STR, FLGS_ESC_MSB);
1266	60		CONSTANT2(ASN1_STR, FLGS_UTF8_CONVERT);
1267	60		CONSTANT2(ASN1_STR, FLGS_IGNORE_TYPE);
1268	60		CONSTANT2(ASN1_STR, FLGS_SHOW_TYPE);
1269	60		CONSTANT2(ASN1_STR, FLGS_DUMP_ALL);
1270	60		CONSTANT2(ASN1_STR, FLGS_DUMP_UNKNOWN);
1271	60		CONSTANT2(ASN1_STR, FLGS_DUMP_DER);
1272	60		CONSTANT2(ASN1_STR, FLGS_ESC_2254);
1273	60		CONSTANT2(ASN1_STR, FLGS_RFC2253);
1274			}
1275
1276			Crypt::OpenSSL3::ASN1::String ASN1_STRING_new()
1277			C_ARGS:
1278
1279			int ASN1_STRING_length(Crypt::OpenSSL3::ASN1::String x)
1280
1281			SV* ASN1_STRING_get_data(Crypt::OpenSSL3::ASN1::String x)
1282			CODE:
1283	0		const unsigned char* data = ASN1_STRING_get0_data(x);
1284	0		int length = ASN1_STRING_length(x);
1285	0		RETVAL = newSVpvn((const char*)data, length);
1286			OUTPUT: RETVAL
1287
1288			Crypt::OpenSSL3::ASN1::String ASN1_STRING_dup(Crypt::OpenSSL3::ASN1::String a)
1289
1290			int ASN1_STRING_cmp(Crypt::OpenSSL3::ASN1::String a, Crypt::OpenSSL3::ASN1::String b)
1291
1292			bool ASN1_STRING_set(Crypt::OpenSSL3::ASN1::String str, const char *data, int length(data))
1293
1294			int ASN1_STRING_type(Crypt::OpenSSL3::ASN1::String x)
1295
1296			SV* ASN1_STRING_to_UTF8(Crypt::OpenSSL3::ASN1::String in)
1297			CODE:
1298	0		unsigned char* out = NULL;
1299	0		int result = ASN1_STRING_to_UTF8(&out, in);
1300	0	0	if (result > 0) {
1301	0		RETVAL = newSVpvn_utf8((char*)out, result, 1);
1302	0		OPENSSL_free(out);
1303			} else
1304	0		RETVAL = &PL_sv_undef;
1305			OUTPUT: RETVAL
1306
1307			bool ASN1_STRING_print(Crypt::OpenSSL3::BIO out, Crypt::OpenSSL3::ASN1::String str)
1308
1309			PrintRet ASN1_STRING_print_ex(Crypt::OpenSSL3::BIO out, Crypt::OpenSSL3::ASN1::String str, unsigned long flags)
1310
1311			MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::ASN1::Time PREFIX = ASN1_TIME_
1312
1313			Crypt::OpenSSL3::ASN1::Time ASN1_TIME_new(class)
1314			C_ARGS:
1315
1316			Crypt::OpenSSL3::ASN1::Time ASN1_TIME_dup(Crypt::OpenSSL3::ASN1::Time t);
1317
1318			bool ASN1_TIME_set(Crypt::OpenSSL3::ASN1::Time s, time_t t)
1319
1320			bool ASN1_TIME_adj(Crypt::OpenSSL3::ASN1::Time s, time_t t, int offset_day, long offset_sec)
1321
1322			bool ASN1_TIME_set_string(Crypt::OpenSSL3::ASN1::Time s, const char *str)
1323
1324			bool ASN1_TIME_set_string_X509(Crypt::OpenSSL3::ASN1::Time s, const char *str)
1325
1326			bool ASN1_TIME_normalize(Crypt::OpenSSL3::ASN1::Time s)
1327
1328			bool ASN1_TIME_check(Crypt::OpenSSL3::ASN1::Time t)
1329
1330			bool ASN1_TIME_print(Crypt::OpenSSL3::BIO b, Crypt::OpenSSL3::ASN1::Time s)
1331
1332			PrintRet ASN1_TIME_print_ex(Crypt::OpenSSL3::BIO bp, Crypt::OpenSSL3::ASN1::Time tm, unsigned long flags)
1333
1334			NO_OUTPUT bool ASN1_TIME_diff(Crypt::OpenSSL3::ASN1::Time from, Crypt::OpenSSL3::ASN1::Time to, OUTLIST int pday, OUTLIST int psec)
1335			C_ARGS: &pday, &psec, from, to
1336			POSTCALL:
1337	0	0	if (!RETVAL)
1338	0		XSRETURN_EMPTY;
1339
1340			int ASN1_TIME_cmp_time(Crypt::OpenSSL3::ASN1::Time s, time_t t)
1341
1342			int ASN1_TIME_compare(Crypt::OpenSSL3::ASN1::Time a, Crypt::OpenSSL3::ASN1::Time b)
1343			POSTCALL:
1344	0	0	if (RETVAL == -2)
1345	0		XSRETURN_UNDEF;
1346
1347			void ASN1_TIME_to_tm(Crypt::OpenSSL3::ASN1::Time s)
1348			PPCODE:
1349			struct tm tm;
1350	0	0	if (ASN1_TIME_to_tm(s, &tm)) {
1351	0	0	EXTEND(SP, 9);
1352	0		mPUSHi(tm.tm_sec);
1353	0		mPUSHi(tm.tm_min);
1354	0		mPUSHi(tm.tm_hour);
1355	0		mPUSHi(tm.tm_mday);
1356	0		mPUSHi(tm.tm_mon);
1357	0		mPUSHi(tm.tm_year);
1358	0		mPUSHi(tm.tm_wday);
1359	0		mPUSHi(tm.tm_yday);
1360	0		mPUSHi(tm.tm_isdst);
1361			}
1362
1363			Crypt::OpenSSL3::ASN1::Time::Generalized ASN1_TIME_to_generalizedtime(Crypt::OpenSSL3::ASN1::Time t)
1364			C_ARGS: t, NULL
1365			POSTCALL:
1366	0	0	if (!RETVAL)
1367	0		XSRETURN_UNDEF;
1368
1369
1370			MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::ASN1::Time::Generalized PREFIX = ASN1_GENERALIZEDTIME_
1371
1372			Crypt::OpenSSL3::ASN1::Time::Generalized ASN1_GENERALIZEDTIME_new(class)
1373			C_ARGS:
1374
1375			Crypt::OpenSSL3::ASN1::Time::Generalized ASN1_GENERALIZEDTIME_dup(Crypt::OpenSSL3::ASN1::Time::Generalized t);
1376
1377			bool ASN1_GENERALIZEDTIME_set(Crypt::OpenSSL3::ASN1::Time::Generalized s, time_t t)
1378
1379			bool ASN1_GENERALIZEDTIME_adj(Crypt::OpenSSL3::ASN1::Time::Generalized s, time_t t, int offset_day, long offset_sec)
1380
1381			bool ASN1_GENERALIZEDTIME_set_string(Crypt::OpenSSL3::ASN1::Time::Generalized s, const char *str)
1382
1383			bool ASN1_GENERALIZEDTIME_check(Crypt::OpenSSL3::ASN1::Time::Generalized t)
1384
1385			bool ASN1_GENERALIZEDTIME_print(Crypt::OpenSSL3::BIO b, Crypt::OpenSSL3::ASN1::Time::Generalized s)
1386
1387
1388			MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::ASN1::Time::UTC PREFIX = ASN1_UTCTIME_
1389
1390			Crypt::OpenSSL3::ASN1::Time::UTC ASN1_UTCTIME_new(class)
1391			C_ARGS:
1392
1393			Crypt::OpenSSL3::ASN1::Time::UTC ASN1_UTCTIME_dup(Crypt::OpenSSL3::ASN1::Time::UTC t);
1394
1395			bool ASN1_UTCTIME_set(Crypt::OpenSSL3::ASN1::Time::UTC s, time_t t)
1396
1397			bool ASN1_UTCTIME_adj(Crypt::OpenSSL3::ASN1::Time::UTC s, time_t t, int offset_day, long offset_sec)
1398
1399			bool ASN1_UTCTIME_set_string(Crypt::OpenSSL3::ASN1::Time::UTC s, const char *str)
1400
1401			int ASN1_UTCTIME_cmp_time_t(Crypt::OpenSSL3::ASN1::Time::UTC s, time_t t)
1402
1403			bool ASN1_UTCTIME_check(Crypt::OpenSSL3::ASN1::Time::UTC t)
1404
1405			bool ASN1_UTCTIME_print(Crypt::OpenSSL3::BIO b, Crypt::OpenSSL3::ASN1::Time::UTC s)
1406
1407
1408			MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::X509 PREFIX = X509_
1409
1410			BOOT:
1411			{
1412	60		HV* stash = gv_stashpvs("Crypt::OpenSSL3::X509", GV_ADD \| GV_ADDMULTI);
1413	60		CONSTANT2(X509_, CHECK_FLAG_ALWAYS_CHECK_SUBJECT);
1414	60		CONSTANT2(X509_, CHECK_FLAG_NEVER_CHECK_SUBJECT);
1415	60		CONSTANT2(X509_, CHECK_FLAG_NO_WILDCARDS);
1416	60		CONSTANT2(X509_, CHECK_FLAG_NO_PARTIAL_WILDCARDS);
1417	60		CONSTANT2(X509_, CHECK_FLAG_MULTI_LABEL_WILDCARDS);
1418	60		CONSTANT2(X509_, CHECK_FLAG_SINGLE_LABEL_SUBDOMAINS);
1419			}
1420
1421			Crypt::OpenSSL3::X509 X509_new(class)
1422			C_ARGS:
1423
1424			Crypt::OpenSSL3::X509 X509_dup(Crypt::OpenSSL3::X509 self)
1425
1426			Crypt::OpenSSL3::X509 X509_read_pem(class, Crypt::OpenSSL3::BIO bio)
1427			C_ARGS: bio, NULL, NULL, NULL
1428			POSTCALL:
1429	0	0	if (!RETVAL)
1430	0		XSRETURN_UNDEF;
1431
1432			bool X509_write_pem(Crypt::OpenSSL3::X509 x, Crypt::OpenSSL3::BIO bio)
1433			C_ARGS: bio, x
1434
1435			Crypt::OpenSSL3::X509 X509_read_der(class, Crypt::OpenSSL3::BIO bio)
1436			C_ARGS: bio, NULL
1437			POSTCALL:
1438	0	0	if (!RETVAL)
1439	0		XSRETURN_UNDEF;
1440
1441			bool X509_write_der(Crypt::OpenSSL3::X509 x, Crypt::OpenSSL3::BIO bio)
1442			C_ARGS: bio, x
1443
1444			const char *X509_get_default_cert_file(class)
1445			C_ARGS:
1446
1447			const char *X509_get_default_cert_dir(class)
1448			C_ARGS:
1449
1450			const char *X509_get_default_cert_file_env(class)
1451			C_ARGS:
1452
1453			const char *X509_get_default_cert_dir_env(class)
1454			C_ARGS:
1455
1456			bool X509_sign(Crypt::OpenSSL3::X509 x, Crypt::OpenSSL3::PKey pkey, Crypt::OpenSSL3::MD md)
1457
1458			bool X509_sign_ctx(Crypt::OpenSSL3::X509 x, Crypt::OpenSSL3::MD::Context ctx)
1459
1460			bool X509_verify(Crypt::OpenSSL3::X509 x, Crypt::OpenSSL3::PKey pkey)
1461
1462			bool X509_self_signed(Crypt::OpenSSL3::X509 cert, bool verify_signature)
1463
1464			Crypt::OpenSSL3::PKey X509_get_pubkey(Crypt::OpenSSL3::X509 x)
1465
1466			bool X509_set_pubkey(Crypt::OpenSSL3::X509 x, Crypt::OpenSSL3::PKey pkey);
1467
1468			long X509_get_version(Crypt::OpenSSL3::X509 x)
1469
1470			bool X509_set_version(Crypt::OpenSSL3::X509 x, long version)
1471
1472			void X509_get_signature(Crypt::OpenSSL3::X509 x, OUTLIST Crypt::OpenSSL3::ASN1::String psig, OUTLIST Crypt::OpenSSL3::X509::Algorithm palg)
1473			C_ARGS: (const ASN1_BIT_STRING)&psig, (const X509_ALGOR)&palg, x
1474			POSTCALL:
1475	0		psig = ASN1_STRING_dup(psig);
1476	0		palg = X509_ALGOR_dup(palg);
1477
1478			Crypt::OpenSSL3::NID X509_get_signature_nid(Crypt::OpenSSL3::X509 x)
1479
1480			Crypt::OpenSSL3::X509::Algorithm X509_get_tbs_sigalg(Crypt::OpenSSL3::X509 x)
1481			POSTCALL:
1482	0		RETVAL = X509_ALGOR_dup(RETVAL);
1483
1484			Crypt::OpenSSL3::ASN1::Time X509_get_notBefore(Crypt::OpenSSL3::X509 x)
1485			INTERFACE: X509_get_notBefore X509_get_notAfter
1486			POSTCALL:
1487	0		RETVAL = ASN1_TIME_dup(RETVAL);
1488
1489			bool X509_set_notBefore(Crypt::OpenSSL3::X509 x, Crypt::OpenSSL3::ASN1::Time tm)
1490
1491			bool X509_set_notAfter(Crypt::OpenSSL3::X509 x, Crypt::OpenSSL3::ASN1::Time tm)
1492
1493			Crypt::OpenSSL3::X509::Name X509_get_subject_name(Crypt::OpenSSL3::X509 x)
1494			INTERFACE:
1495			X509_get_subject_name X509_get_issuer_name
1496			POSTCALL:
1497	0		RETVAL = X509_NAME_dup(RETVAL);
1498
1499			bool X509_set_subject_name(Crypt::OpenSSL3::X509 x, Crypt::OpenSSL3::X509::Name name)
1500
1501			bool X509_set_issuer_name(Crypt::OpenSSL3::X509 x, Crypt::OpenSSL3::X509::Name name)
1502
1503			unsigned long X509_subject_name_hash(Crypt::OpenSSL3::X509 x)
1504
1505			unsigned long X509_issuer_name_hash(Crypt::OpenSSL3::X509 x)
1506
1507			NO_OUTPUT Bool X509_digest(Crypt::OpenSSL3::X509 data, Crypt::OpenSSL3::MD type, OUTLIST SV* digest)
1508			INTERFACE: X509_digest X509_pubkey_digest
1509			INIT:
1510	0		unsigned int output_length = EVP_MD_size(type);
1511	0		unsigned char* ptr = make_buffer(&digest, output_length);
1512			C_ARGS: data, type, ptr, &output_length
1513			POSTCALL:
1514	0	0	if (RETVAL)
1515	0		set_buffer_length(digest, output_length);
1516
1517			Crypt::OpenSSL3::ASN1::String X509_digest_sig(Crypt::OpenSSL3::X509 cert)
1518			C_ARGS: cert, NULL, NULL
1519
1520			Crypt::OpenSSL3::ASN1::String X509_get_distinguishing_id(Crypt::OpenSSL3::X509 x)
1521
1522			void X509_set_distinguishing_id(Crypt::OpenSSL3::X509 x, Crypt::OpenSSL3::ASN1::String distid)
1523			INIT:
1524	0		distid = ASN1_OCTET_STRING_dup(distid);
1525
1526			bool X509_check_ca(Crypt::OpenSSL3::X509 cert)
1527
1528			bool X509_check_host(Crypt::OpenSSL3::X509 cert, const char name, size_t length(name), unsigned int flags, OUTLIST char peername)
1529
1530			bool X509_check_email(Crypt::OpenSSL3::X509 cert, const char *address, size_t length(address), unsigned int flags)
1531
1532			bool X509_check_ip(Crypt::OpenSSL3::X509 cert, const unsigned char *address, size_t length(address), unsigned int flags)
1533
1534			bool X509_check_ip_asc(Crypt::OpenSSL3::X509 cert, const char *address, unsigned int flags)
1535
1536			bool X509_check_issued(Crypt::OpenSSL3::X509 issuer, Crypt::OpenSSL3::X509 subject)
1537
1538			bool X509_check_private_key(Crypt::OpenSSL3::X509 cert, Crypt::OpenSSL3::PKey pkey)
1539
1540			int X509_cmp(Crypt::OpenSSL3::X509 a, Crypt::OpenSSL3::X509 b)
1541
1542			int X509_issuer_and_serial_cmp(Crypt::OpenSSL3::X509 a, Crypt::OpenSSL3::X509 b)
1543
1544			int X509_issuer_name_cmp(Crypt::OpenSSL3::X509 a, Crypt::OpenSSL3::X509 b)
1545
1546			int X509_subject_name_cmp(Crypt::OpenSSL3::X509 a, Crypt::OpenSSL3::X509 b)
1547
1548			long X509_get_pathlen(Crypt::OpenSSL3::X509 x)
1549
1550			uint32_t X509_get_extension_flags(Crypt::OpenSSL3::X509 x)
1551
1552			uint32_t X509_get_key_usage(Crypt::OpenSSL3::X509 x)
1553
1554			uint32_t X509_get_extended_key_usage(Crypt::OpenSSL3::X509 x)
1555
1556			Crypt::OpenSSL3::ASN1::String X509_get_subject_key_id(Crypt::OpenSSL3::X509 x)
1557			POSTCALL:
1558	0	0	if (RETVAL)
1559	0		RETVAL = ASN1_OCTET_STRING_dup(RETVAL);
1560			else
1561	0		XSRETURN_UNDEF;
1562
1563			Crypt::OpenSSL3::ASN1::String X509_get_authority_key_id(Crypt::OpenSSL3::X509 x)
1564			POSTCALL:
1565	0	0	if (RETVAL)
1566	0		RETVAL = ASN1_OCTET_STRING_dup(RETVAL);
1567			else
1568	0		XSRETURN_UNDEF;
1569
1570			Crypt::OpenSSL3::X509::GeneralName X509_get_authority_issuer(Crypt::OpenSSL3::X509 x)
1571			POSTCALL:
1572	0	0	if (RETVAL)
1573	0		RETVAL = GENERAL_NAME_dup(RETVAL);
1574			else
1575	0		XSRETURN_UNDEF;
1576
1577			Crypt::OpenSSL3::ASN1::Integer X509_get_authority_serial(Crypt::OpenSSL3::X509 x)
1578			POSTCALL:
1579	0	0	if (RETVAL)
1580	0		RETVAL = ASN1_INTEGER_dup(RETVAL);
1581			else
1582	0		XSRETURN_UNDEF;
1583
1584			void X509_set_proxy_flag(Crypt::OpenSSL3::X509 x)
1585
1586			void X509_set_proxy_pathlen(Crypt::OpenSSL3::X509 x, int l)
1587
1588			long X509_get_proxy_pathlen(Crypt::OpenSSL3::X509 x)
1589
1590			int X509_get_ext_count(Crypt::OpenSSL3::X509 x)
1591
1592			Crypt::OpenSSL3::X509::Extension X509_get_ext(Crypt::OpenSSL3::X509 x, int loc)
1593
1594			int X509_get_ext_by_NID(Crypt::OpenSSL3::X509 x, Crypt::OpenSSL3::NID nid, int lastpos = -1)
1595
1596			int X509_get_ext_by_OBJ(Crypt::OpenSSL3::X509 x, Crypt::OpenSSL3::ASN1::Object obj, int lastpos = -1)
1597
1598			int X509_get_ext_by_critical(Crypt::OpenSSL3::X509 x, int crit, int lastpos = -1)
1599
1600			Crypt::OpenSSL3::X509::Extension X509_delete_ext(Crypt::OpenSSL3::X509 x, int loc)
1601
1602			int X509_add_ext(Crypt::OpenSSL3::X509 x, Crypt::OpenSSL3::X509::Extension ex, int loc = -1)
1603
1604			Crypt::OpenSSL3::ASN1::Integer X509_get_serialNumber(Crypt::OpenSSL3::X509 x)
1605
1606			bool X509_set_serialNumber(Crypt::OpenSSL3::X509 x, Crypt::OpenSSL3::ASN1::Integer serial)
1607
1608
1609			MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::X509::VerifyParam PREFIX = X509_VERIFY_PARAM_
1610
1611			Crypt::OpenSSL3::X509::VerifyParam X509_VERIFY_PARAM_new(class)
1612			C_ARGS:
1613
1614			bool X509_VERIFY_PARAM_set_flags(Crypt::OpenSSL3::X509::VerifyParam param, unsigned long flags)
1615
1616			bool X509_VERIFY_PARAM_clear_flags(Crypt::OpenSSL3::X509::VerifyParam param, unsigned long flags)
1617
1618			unsigned long X509_VERIFY_PARAM_get_flags(Crypt::OpenSSL3::X509::VerifyParam param)
1619
1620			bool X509_VERIFY_PARAM_set_inh_flags(Crypt::OpenSSL3::X509::VerifyParam param, uint32_t flags)
1621
1622			uint32_t X509_VERIFY_PARAM_get_inh_flags(Crypt::OpenSSL3::X509::VerifyParam param)
1623
1624			bool X509_VERIFY_PARAM_set_purpose(Crypt::OpenSSL3::X509::VerifyParam param, int purpose)
1625
1626			#if OPENSSL_VERSION_PREREQ(3, 5)
1627			int X509_VERIFY_PARAM_get_purpose(Crypt::OpenSSL3::X509::VerifyParam param)
1628			#endif
1629
1630			bool X509_VERIFY_PARAM_set_trust(Crypt::OpenSSL3::X509::VerifyParam param, int trust)
1631
1632			void X509_VERIFY_PARAM_set_time(Crypt::OpenSSL3::X509::VerifyParam param, time_t t)
1633
1634			time_t X509_VERIFY_PARAM_get_time(Crypt::OpenSSL3::X509::VerifyParam param)
1635
1636			bool X509_VERIFY_PARAM_add_policy(Crypt::OpenSSL3::X509::VerifyParam param, Crypt::OpenSSL3::ASN1::Object policy)
1637			C_ARGS: param, (ASN1_OBJECT*)policy
1638
1639			#if 0
1640			bool X509_VERIFY_PARAM_set1_policies(Crypt::OpenSSL3::X509::VerifyParam param, Crypt::OpenSSL3::ASN1::Object policies)
1641			#endif
1642
1643			void X509_VERIFY_PARAM_set_depth(Crypt::OpenSSL3::X509::VerifyParam param, int depth)
1644
1645			int X509_VERIFY_PARAM_get_depth(Crypt::OpenSSL3::X509::VerifyParam param)
1646
1647			void X509_VERIFY_PARAM_set_auth_level(Crypt::OpenSSL3::X509::VerifyParam param, int auth_level)
1648
1649			int X509_VERIFY_PARAM_get_auth_level(Crypt::OpenSSL3::X509::VerifyParam param)
1650
1651			char *X509_VERIFY_PARAM_get_host(Crypt::OpenSSL3::X509::VerifyParam param, int n)
1652
1653			bool X509_VERIFY_PARAM_set_host(Crypt::OpenSSL3::X509::VerifyParam param, const char *name, size_t length(name))
1654
1655			bool X509_VERIFY_PARAM_add_host(Crypt::OpenSSL3::X509::VerifyParam param, const char *name, size_t length(name))
1656
1657			void X509_VERIFY_PARAM_set_hostflags(Crypt::OpenSSL3::X509::VerifyParam param, unsigned int flags)
1658
1659			unsigned int X509_VERIFY_PARAM_get_hostflags(Crypt::OpenSSL3::X509::VerifyParam param)
1660
1661			char *X509_VERIFY_PARAM_get_peername(Crypt::OpenSSL3::X509::VerifyParam param)
1662
1663			char *X509_VERIFY_PARAM_get_email(Crypt::OpenSSL3::X509::VerifyParam param)
1664
1665			bool X509_VERIFY_PARAM_set_email(Crypt::OpenSSL3::X509::VerifyParam param, const char *email, size_t length(email))
1666
1667			char *X509_VERIFY_PARAM_get_ip_asc(Crypt::OpenSSL3::X509::VerifyParam param)
1668			CLEANUP:
1669	0		OPENSSL_free(RETVAL);
1670
1671			bool X509_VERIFY_PARAM_set_ip(Crypt::OpenSSL3::X509::VerifyParam param, const unsigned char *ip, size_t length(ip))
1672
1673			bool X509_VERIFY_PARAM_set_ip_asc(Crypt::OpenSSL3::X509::VerifyParam param, const char *ipasc)
1674
1675
1676			MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::X509::GeneralName PREFIX = GENERAL_NAME_
1677
1678			Crypt::OpenSSL3::X509::GeneralName GENERAL_NAME_new(class)
1679			C_ARGS:
1680
1681			#if OPENSSL_VERSION_PREREQ(3, 4)
1682			NO_OUTPUT int GENERAL_NAME_new_from_x509_name(OUTLIST Crypt::OpenSSL3::X509::GeneralName name, Crypt::OpenSSL3::X509::Name src)
1683			POSTCALL:
1684			if (!RETVAL)
1685			XSRETURN_UNDEF;
1686			#endif
1687
1688			Crypt::OpenSSL3::X509::GeneralName GENERAL_NAME_dup(Crypt::OpenSSL3::X509::GeneralName gn)
1689
1690			int GENERAL_NAME_type(Crypt::OpenSSL3::X509::GeneralName gn)
1691
1692			SV* GENERAL_NAME_to_string(Crypt::OpenSSL3::X509::GeneralName gn)
1693			CODE:
1694	0		switch (gn->type) {
1695	0		case GEN_OTHERNAME: {
1696	0		ASN1_UTF8STRING* str = gn->d.otherName->value->value.utf8string;
1697	0		RETVAL = newSVpvn((const char*)ASN1_STRING_get0_data(str), ASN1_STRING_length(str));
1698	0		break;
1699			}
1700	0		case GEN_EMAIL:
1701			case GEN_DNS:
1702			case GEN_X400:
1703			case GEN_URI:
1704			case GEN_IPADD: {
1705	0		ASN1_STRING* str = gn->d.rfc822Name;
1706	0		const unsigned char* data = ASN1_STRING_get0_data(str);
1707	0		int length = ASN1_STRING_length(str);
1708	0		RETVAL = newSVpvn((const char*)data, length);
1709	0		break;
1710			}
1711	0		case GEN_DIRNAME: {
1712	0		char* str = X509_NAME_oneline(gn->d.directoryName, NULL, 0);
1713	0		RETVAL = newSVpv(str, 0);
1714	0		OPENSSL_free(str);
1715	0		break;
1716			}
1717	0		case GEN_RID: {
1718	0		RETVAL = OBJ_to_text(gn->d.registeredID, 1);
1719	0		break;
1720			}
1721	0		default:
1722	0		RETVAL = &PL_sv_undef;
1723			}
1724			OUTPUT: RETVAL
1725
1726			SV* GENERAL_NAME_to_value(Crypt::OpenSSL3::X509::GeneralName gn)
1727			CODE:
1728	0		switch (gn->type) {
1729	0		case GEN_OTHERNAME: {
1730	0		ASN1_UTF8STRING* str = gn->d.otherName->value->value.utf8string;
1731	0		RETVAL = make_ASN1_STRING(aTHX_ ASN1_STRING_dup(str));
1732	0		break;
1733			}
1734	0		case GEN_EMAIL:
1735			case GEN_DNS:
1736			case GEN_X400:
1737			case GEN_URI:
1738			case GEN_IPADD:
1739	0		RETVAL = make_ASN1_STRING(aTHX_ ASN1_STRING_dup(gn->d.rfc822Name));
1740	0		break;
1741	0		case GEN_RID:
1742	0		RETVAL = make_ASN1_OBJECT(aTHX_ gn->d.registeredID);
1743	0		break;
1744	0		case GEN_DIRNAME:
1745	0		RETVAL = make_X509_NAME(aTHX_ X509_NAME_dup(gn->d.directoryName));
1746	0		break;
1747	0		default:
1748	0		RETVAL = &PL_sv_undef;
1749			}
1750			OUTPUT: RETVAL
1751
1752
1753			MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::X509::Algorithm PREFIX = X509_ALGOR_
1754
1755			Crypt::OpenSSL3::X509::Algorithm X509_ALGOR_new(class)
1756			C_ARGS:
1757
1758			Crypt::OpenSSL3::X509::Algorithm X509_ALGOR_dup(Crypt::OpenSSL3::X509::Algorithm alg)
1759
1760			bool X509_ALGOR_set(Crypt::OpenSSL3::X509::Algorithm alg, Crypt::OpenSSL3::ASN1::Object aobj)
1761			C_ARGS: alg, (ASN1_OBJECT*)aobj, V_ASN1_UNDEF, NULL
1762
1763			void X509_ALGOR_get(Crypt::OpenSSL3::X509::Algorithm alg, OUTLIST Crypt::OpenSSL3::ASN1::Object paobj)
1764			C_ARGS: (const ASN1_OBJECT**)&paobj, NULL, NULL, alg
1765
1766			void X509_ALGOR_set_md(Crypt::OpenSSL3::X509::Algorithm alg, Crypt::OpenSSL3::MD md)
1767
1768			int X509_ALGOR_cmp(Crypt::OpenSSL3::X509::Algorithm a, Crypt::OpenSSL3::X509::Algorithm b)
1769
1770			bool X509_ALGOR_copy(Crypt::OpenSSL3::X509::Algorithm dest, Crypt::OpenSSL3::X509::Algorithm src)
1771
1772
1773			MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::X509::Attribute PREFIX = X509_ATTRIBUTE_
1774
1775
1776			Crypt::OpenSSL3::X509::Attribute X509_ATTRIBUTE_create(class, Crypt::OpenSSL3::NID nid, int atrtype, char *value)
1777			C_ARGS: nid, atrtype, value
1778
1779			Crypt::OpenSSL3::X509::Attribute X509_ATTRIBUTE_create_by_NID(class, Crypt::OpenSSL3::NID nid, int atrtype, const char *data, int length(data))
1780			C_ARGS: NULL, nid, atrtype, data, XSauto_length_of_data
1781
1782			Crypt::OpenSSL3::X509::Attribute X509_ATTRIBUTE_create_by_OBJ(class, Crypt::OpenSSL3::ASN1::Object obj, int atrtype, const char *data, int length(data))
1783			C_ARGS: NULL, obj, atrtype, data, XSauto_length_of_data
1784
1785			Crypt::OpenSSL3::X509::Attribute X509_ATTRIBUTE_create_by_txt(class, const char atrname, int type, const unsigned char bytes, int length(bytes))
1786			C_ARGS: NULL, atrname, type, bytes, XSauto_length_of_bytes
1787
1788			bool X509_ATTRIBUTE_set_object(Crypt::OpenSSL3::X509::Attribute attr, Crypt::OpenSSL3::ASN1::Object obj)
1789
1790			bool X509_ATTRIBUTE_set_data(Crypt::OpenSSL3::X509::Attribute attr, int attrtype, const char *data, int length(data))
1791
1792			const char *X509_ATTRIBUTE_get_data(Crypt::OpenSSL3::X509::Attribute attr, int idx, int atrtype)
1793			C_ARGS: attr, idx, atrtype, NULL
1794
1795			PrintRet X509_ATTRIBUTE_count(Crypt::OpenSSL3::X509::Attribute attr)
1796
1797			Crypt::OpenSSL3::ASN1::Object X509_ATTRIBUTE_get_object(Crypt::OpenSSL3::X509::Attribute attr)
1798
1799
1800			MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::X509::Extension PREFIX = X509_EXTENSION_
1801
1802			Crypt::OpenSSL3::X509::Extension X509_EXTENSION_new(class)
1803			C_ARGS:
1804
1805			Crypt::OpenSSL3::X509::Extension X509_EXTENSION_dup(Crypt::OpenSSL3::X509::Extension ex)
1806
1807			bool X509_EXTENSION_set_object(Crypt::OpenSSL3::X509::Extension ex, Crypt::OpenSSL3::ASN1::Object obj)
1808
1809			bool X509_EXTENSION_set_critical(Crypt::OpenSSL3::X509::Extension ex, bool crit)
1810
1811			bool X509_EXTENSION_set_data(Crypt::OpenSSL3::X509::Extension ex, Crypt::OpenSSL3::ASN1::String data)
1812
1813			Crypt::OpenSSL3::X509::Extension X509_EXTENSION_create_by_NID(Crypt::OpenSSL3::NID nid, bool crit, Crypt::OpenSSL3::ASN1::String data)
1814			C_ARGS: NULL, nid, crit, data
1815
1816			Crypt::OpenSSL3::X509::Extension X509_EXTENSION_create_by_OBJ(Crypt::OpenSSL3::ASN1::Object obj, bool crit, Crypt::OpenSSL3::ASN1::String data)
1817			C_ARGS: NULL, obj, crit, data
1818
1819			Crypt::OpenSSL3::ASN1::Object X509_EXTENSION_get_object(Crypt::OpenSSL3::X509::Extension ex)
1820
1821			bool X509_EXTENSION_get_critical(Crypt::OpenSSL3::X509::Extension ex)
1822
1823			Crypt::OpenSSL3::ASN1::String X509_EXTENSION_get_data(Crypt::OpenSSL3::X509::Extension ne)
1824
1825
1826			MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::X509::Stack PREFIX = sk_X509_
1827
1828			int sk_X509_num(Crypt::OpenSSL3::X509::Stack sk)
1829
1830			Crypt::OpenSSL3::X509 sk_X509_value(Crypt::OpenSSL3::X509::Stack sk, int idx)
1831
1832			Crypt::OpenSSL3::X509::Stack sk_X509_new(class)
1833			C_ARGS: NULL
1834
1835			int sk_X509_reserve(Crypt::OpenSSL3::X509::Stack sk, int n)
1836
1837			void sk_X509_free(Crypt::OpenSSL3::X509::Stack sk)
1838
1839			void sk_X509_zero(Crypt::OpenSSL3::X509::Stack sk)
1840
1841			Crypt::OpenSSL3::X509 sk_X509_delete(Crypt::OpenSSL3::X509::Stack sk, int i)
1842
1843			Crypt::OpenSSL3::X509 sk_X509_delete_ptr(Crypt::OpenSSL3::X509::Stack sk, Crypt::OpenSSL3::X509 ptr)
1844
1845			int sk_X509_push(Crypt::OpenSSL3::X509::Stack sk, Crypt::OpenSSL3::X509 ptr)
1846
1847			int sk_X509_unshift(Crypt::OpenSSL3::X509::Stack sk, Crypt::OpenSSL3::X509 ptr)
1848
1849			Crypt::OpenSSL3::X509 sk_X509_pop(Crypt::OpenSSL3::X509::Stack sk)
1850
1851			Crypt::OpenSSL3::X509 sk_X509_shift(Crypt::OpenSSL3::X509::Stack sk)
1852
1853			void sk_X509_pop_free(Crypt::OpenSSL3::X509::Stack sk)
1854			C_ARGS: sk, X509_free
1855
1856			int sk_X509_insert(Crypt::OpenSSL3::X509::Stack sk, Crypt::OpenSSL3::X509 ptr, int idx)
1857
1858			Crypt::OpenSSL3::X509 sk_X509_set(Crypt::OpenSSL3::X509::Stack sk, int idx, Crypt::OpenSSL3::X509 ptr)
1859
1860			int sk_X509_find(Crypt::OpenSSL3::X509::Stack sk, Crypt::OpenSSL3::X509 ptr)
1861
1862			int sk_X509_find_ex(Crypt::OpenSSL3::X509::Stack sk, Crypt::OpenSSL3::X509 ptr)
1863
1864			int sk_X509_find_all(Crypt::OpenSSL3::X509::Stack sk, Crypt::OpenSSL3::X509 ptr, OUT int pnum)
1865
1866			void sk_X509_sort(Crypt::OpenSSL3::X509::Stack sk)
1867
1868			int sk_X509_is_sorted(Crypt::OpenSSL3::X509::Stack sk)
1869
1870
1871			MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::X509::VerifyResult PREFIX = X509_verify_cert_
1872
1873			IV X509_verify_cert_error_code(Crypt::OpenSSL3::X509::VerifyResult result)
1874
1875			bool X509_verify_cert_ok(Crypt::OpenSSL3::X509::VerifyResult result)
1876
1877			const char* X509_verify_cert_error_string(Crypt::OpenSSL3::X509::VerifyResult result)
1878
1879			MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::X509::Name PREFIX = X509_NAME_
1880
1881			Crypt::OpenSSL3::X509::Name X509_NAME_new(class)
1882			C_ARGS:
1883
1884			Crypt::OpenSSL3::X509::Name X509_NAME_dup(Crypt::OpenSSL3::X509::Name self)
1885
1886			int X509_NAME_cmp(Crypt::OpenSSL3::X509::Name a, Crypt::OpenSSL3::X509::Name b)
1887
1888			int X509_NAME_get_index_by_NID(Crypt::OpenSSL3::X509::Name name, Crypt::OpenSSL3::NID nid, int lastpos)
1889
1890			int X509_NAME_get_index_by_OBJ(Crypt::OpenSSL3::X509::Name name, Crypt::OpenSSL3::ASN1::Object obj, int lastpos)
1891
1892			int X509_NAME_entry_count(Crypt::OpenSSL3::X509::Name name)
1893
1894			Crypt::OpenSSL3::X509::Name::Entry X509_NAME_get_entry(Crypt::OpenSSL3::X509::Name name, int loc)
1895			POSTCALL:
1896	0		RETVAL = X509_NAME_ENTRY_dup(RETVAL);
1897
1898			char* X509_NAME_oneline(Crypt::OpenSSL3::X509::Name a)
1899			C_ARGS: a, NULL, 0
1900			CLEANUP:
1901	0	0	if (RETVAL)
1902	0		OPENSSL_free(RETVAL);
1903
1904			NO_OUTPUT int X509_NAME_digest(Crypt::OpenSSL3::X509::Name data, Crypt::OpenSSL3::MD type, OUTLIST SV* hash)
1905			INIT:
1906	0		unsigned len = EVP_MD_size(type);
1907	0		unsigned char* ptr = make_buffer(&hash, len);
1908			C_ARGS: data, type, ptr, &len
1909			POSTCALL:
1910	0	0	if (RETVAL)
1911	0		set_buffer_length(hash, len);
1912
1913			bool X509_NAME_add_entry_by_txt(Crypt::OpenSSL3::X509::Name name, const char field, int type, const unsigned char bytes, int len, int loc, int set)
1914
1915			bool X509_NAME_add_entry_by_OBJ(Crypt::OpenSSL3::X509::Name name, Crypt::OpenSSL3::ASN1::Object obj, int type, const unsigned char *bytes, int length(bytes), int loc, int set)
1916
1917			bool X509_NAME_add_entry_by_NID(Crypt::OpenSSL3::X509::Name name, Crypt::OpenSSL3::NID nid, int type, const unsigned char *bytes, int len, int loc, int set)
1918
1919			bool X509_NAME_add_entry(Crypt::OpenSSL3::X509::Name name, Crypt::OpenSSL3::X509::Name::Entry ne, int loc, int set)
1920
1921			Crypt::OpenSSL3::X509::Name::Entry X509_NAME_delete_entry(Crypt::OpenSSL3::X509::Name name, int loc)
1922
1923			int X509_NAME_print(Crypt::OpenSSL3::X509::Name nm, Crypt::OpenSSL3::BIO out, int indent, unsigned long flags)
1924			C_ARGS: out, nm, indent, flags
1925
1926			unsigned long X509_NAME_hash(Crypt::OpenSSL3::X509::Name x, const char *propq = NULL)
1927			C_ARGS: x, NULL, propq, NULL
1928
1929			MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::X509::Name::Entry PREFIX = X509_NAME_ENTRY
1930
1931			Crypt::OpenSSL3::X509::Name::Entry X509_NAME_ENTRY_new(class)
1932			C_ARGS:
1933
1934			Crypt::OpenSSL3::ASN1::Object X509_NAME_ENTRY_get_object(Crypt::OpenSSL3::X509::Name::Entry ne)
1935
1936			Crypt::OpenSSL3::ASN1::String X509_NAME_ENTRY_get_data(Crypt::OpenSSL3::X509::Name::Entry ne)
1937
1938			bool X509_NAME_ENTRY_set_object(Crypt::OpenSSL3::X509::Name::Entry ne, Crypt::OpenSSL3::ASN1::Object obj)
1939
1940			bool X509_NAME_ENTRY_set_data(Crypt::OpenSSL3::X509::Name::Entry ne, int type, const unsigned char *bytes, int length(bytes))
1941
1942			MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::X509::Store PREFIX = X509_STORE_
1943
1944			Crypt::OpenSSL3::X509::Store X509_STORE_new(class)
1945			C_ARGS:
1946
1947			bool X509_STORE_lock(Crypt::OpenSSL3::X509::Store store)
1948
1949			bool X509_STORE_unlock(Crypt::OpenSSL3::X509::Store store)
1950
1951			bool X509_STORE_add_cert(Crypt::OpenSSL3::X509::Store store, Crypt::OpenSSL3::X509 x)
1952
1953			bool X509_STORE_set_depth(Crypt::OpenSSL3::X509::Store store, int depth)
1954
1955			bool X509_STORE_set_flags(Crypt::OpenSSL3::X509::Store store, unsigned long flags)
1956
1957			bool X509_STORE_set_purpose(Crypt::OpenSSL3::X509::Store store, int purpose)
1958
1959			bool X509_STORE_set_trust(Crypt::OpenSSL3::X509::Store store, int trust)
1960
1961			bool X509_STORE_load_locations(Crypt::OpenSSL3::X509::Store store, const char file, const char dir)
1962
1963			bool X509_STORE_set_default_paths(Crypt::OpenSSL3::X509::Store store)
1964
1965			bool X509_STORE_load_file(Crypt::OpenSSL3::X509::Store xs, const char file, const char propq = NULL)
1966			C_ARGS: xs, file, NULL, propq
1967
1968			bool X509_STORE_load_path(Crypt::OpenSSL3::X509::Store xs, const char *dir)
1969
1970			bool X509_STORE_load_store(Crypt::OpenSSL3::X509::Store xs, const char uri, const char propq = NULL)
1971			C_ARGS: xs, uri, NULL, propq
1972
1973
1974			MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::X509::Request PREFIX = X509_REQ_
1975
1976			Crypt::OpenSSL3::X509::Request X509_REQ_new(class, const char *propq = NULL)
1977			C_ARGS: NULL, propq
1978
1979			Crypt::OpenSSL3::X509::Request X509_REQ_dup(Crypt::OpenSSL3::X509::Request req)
1980
1981			Crypt::OpenSSL3::X509::Request X509_REQ_read_pem(class, Crypt::OpenSSL3::BIO bio)
1982			C_ARGS: bio, NULL, NULL, NULL
1983			POSTCALL:
1984	0	0	if (!RETVAL)
1985	0		XSRETURN_UNDEF;
1986
1987			bool X509_REQ_write_pem(Crypt::OpenSSL3::X509::Request x, Crypt::OpenSSL3::BIO bio)
1988			C_ARGS: bio, x
1989
1990			Crypt::OpenSSL3::X509::Request X509_REQ_read_der(class, Crypt::OpenSSL3::BIO bio)
1991			C_ARGS: bio, NULL
1992			POSTCALL:
1993	0	0	if (!RETVAL)
1994	0		XSRETURN_UNDEF;
1995
1996			bool X509_REQ_write_der(Crypt::OpenSSL3::X509::Request x, Crypt::OpenSSL3::BIO bio)
1997			C_ARGS: bio, x
1998
1999			int X509_REQ_get_attr_count(Crypt::OpenSSL3::X509::Request req)
2000
2001			int X509_REQ_get_attr_by_NID(Crypt::OpenSSL3::X509::Request req, Crypt::OpenSSL3::NID nid, int lastpos)
2002
2003			int X509_REQ_get_attr_by_OBJ(Crypt::OpenSSL3::X509::Request req, Crypt::OpenSSL3::ASN1::Object obj, int lastpos)
2004
2005			Crypt::OpenSSL3::X509::Attribute X509_REQ_get_attr(Crypt::OpenSSL3::X509::Request req, int loc)
2006
2007			Crypt::OpenSSL3::X509::Attribute X509_REQ_delete_attr(Crypt::OpenSSL3::X509::Request req, int loc)
2008
2009			int X509_REQ_add_attr(Crypt::OpenSSL3::X509::Request req, Crypt::OpenSSL3::X509::Attribute attr)
2010
2011			int X509_REQ_add_attr_by_OBJ(Crypt::OpenSSL3::X509::Request req, Crypt::OpenSSL3::ASN1::Object obj, int type, const unsigned char *bytes, int length(bytes))
2012
2013			int X509_REQ_add_attr_by_NID(Crypt::OpenSSL3::X509::Request req, Crypt::OpenSSL3::NID nid, int type, const unsigned char *bytes, int len)
2014
2015			int X509_REQ_add_attr_by_txt(Crypt::OpenSSL3::X509::Request req, const char attrname, int type, const unsigned char bytes, int len)
2016
2017			bool X509_REQ_check_private_key(Crypt::OpenSSL3::X509::Request cert, Crypt::OpenSSL3::PKey pkey)
2018
2019			NO_OUTPUT Bool X509_REQ_digest(Crypt::OpenSSL3::X509::Request data, Crypt::OpenSSL3::MD type, OUTLIST SV* digest)
2020			INIT:
2021	0		unsigned int output_length = EVP_MD_size(type);
2022	0		unsigned char* ptr = make_buffer(&digest, output_length);
2023			C_ARGS: data, type, ptr, &output_length
2024			POSTCALL:
2025	0	0	if (RETVAL)
2026	0		set_buffer_length(digest, output_length);
2027
2028			Crypt::OpenSSL3::ASN1::String X509_REQ_get_distinguishing_id(Crypt::OpenSSL3::X509::Request x)
2029
2030			void X509_REQ_set_distinguishing_id(Crypt::OpenSSL3::X509::Request x, Crypt::OpenSSL3::ASN1::String distid)
2031			INIT:
2032	0		distid = ASN1_OCTET_STRING_dup(distid);
2033
2034			Crypt::OpenSSL3::PKey X509_REQ_get_pubkey(Crypt::OpenSSL3::X509::Request x)
2035
2036			bool X509_REQ_set_pubkey(Crypt::OpenSSL3::X509::Request x, Crypt::OpenSSL3::PKey pkey)
2037
2038
2039			Crypt::OpenSSL3::X509::Name X509_REQ_get_subject_name(Crypt::OpenSSL3::X509::Request x)
2040			POSTCALL:
2041	0		RETVAL = X509_NAME_dup(RETVAL);
2042
2043			bool X509_REQ_set_subject_name(Crypt::OpenSSL3::X509::Request x, Crypt::OpenSSL3::X509::Name name)
2044
2045			void X509_REQ_set_signature(Crypt::OpenSSL3::X509::Request req, Crypt::OpenSSL3::ASN1::String psig)
2046
2047			void X509_REQ_get_signature(Crypt::OpenSSL3::X509::Request req, OUTLIST Crypt::OpenSSL3::ASN1::String psig, OUTLIST Crypt::OpenSSL3::X509::Algorithm palg)
2048			C_ARGS: req, (const ASN1_BIT_STRING)&psig, (const X509_ALGOR)&palg
2049			POSTCALL:
2050	0		psig = ASN1_OCTET_STRING_dup(psig);
2051	0		palg = X509_ALGOR_dup(palg);
2052
2053			int X509_REQ_set_signature_algo(Crypt::OpenSSL3::X509::Request req, Crypt::OpenSSL3::X509::Algorithm palg)
2054
2055			Crypt::OpenSSL3::NID X509_REQ_get_signature_nid(Crypt::OpenSSL3::X509::Request req)
2056
2057			long X509_REQ_get_version(Crypt::OpenSSL3::X509::Request req)
2058
2059			int X509_REQ_set_version(Crypt::OpenSSL3::X509::Request x, long version)
2060
2061			int X509_REQ_verify(Crypt::OpenSSL3::X509::Request a, Crypt::OpenSSL3::PKey r, const char *propq = NULL)
2062			C_ARGS: a, r, NULL, propq
2063
2064			int X509_REQ_sign(Crypt::OpenSSL3::X509::Request x, Crypt::OpenSSL3::PKey pkey, Crypt::OpenSSL3::MD md)
2065
2066			int X509_REQ_sign_ctx(Crypt::OpenSSL3::X509::Request x, Crypt::OpenSSL3::MD::Context ctx)
2067
2068
2069			MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::PKCS7 PREFIX = PKCS7_
2070
2071			BOOT:
2072			{
2073	60		HV* stash = gv_stashpvs("Crypt::OpenSSL3::PKCS7", GV_ADD \| GV_ADDMULTI);
2074	60		CONSTANT2(PKCS7_, TEXT);
2075	60		CONSTANT2(PKCS7_, BINARY);
2076	60		CONSTANT2(PKCS7_, NOCERTS);
2077	60		CONSTANT2(PKCS7_, DETACHED);
2078	60		CONSTANT2(PKCS7_, NOATTR);
2079	60		CONSTANT2(PKCS7_, NOSMIMECAP);
2080	60		CONSTANT2(PKCS7_, STREAM);
2081			}
2082
2083			Crypt::OpenSSL3::PKCS7 PKCS7_new(class, const char* propq = NULL)
2084			C_ARGS: NULL, propq
2085
2086			Crypt::OpenSSL3::PKCS7 PKCS7_read_pem(class, Crypt::OpenSSL3::BIO bio)
2087			C_ARGS: bio, NULL, NULL, NULL
2088			POSTCALL:
2089	0	0	if (!RETVAL)
2090	0		XSRETURN_UNDEF;
2091
2092			bool PKCS7_write_pem(Crypt::OpenSSL3::PKCS7 x, Crypt::OpenSSL3::BIO bio)
2093			C_ARGS: bio, x
2094
2095			Crypt::OpenSSL3::PKCS7 PKCS7_read_der(class, Crypt::OpenSSL3::BIO bp)
2096			C_ARGS: bp, NULL
2097			POSTCALL:
2098	0	0	if (!RETVAL)
2099	0		XSRETURN_UNDEF;
2100
2101			int PKCS7_write_der(Crypt::OpenSSL3::PKCS7 p7, Crypt::OpenSSL3::BIO bio)
2102			C_ARGS: bio, p7
2103
2104			bool PKCS7_add_certificate(Crypt::OpenSSL3::PKCS7 p7, Crypt::OpenSSL3::X509 cert)
2105
2106			Crypt::OpenSSL3::PKCS7 PKCS7_sign(class, Crypt::OpenSSL3::X509 signcert, Crypt::OpenSSL3::PKey pkey, Crypt::OpenSSL3::X509::Stack certs, Crypt::OpenSSL3::BIO data, int flags, const char *propq = NULL)
2107			C_ARGS: signcert, pkey, certs, data, flags, NULL, propq
2108
2109			bool PKCS7_verify(Crypt::OpenSSL3::PKCS7 p7, Crypt::OpenSSL3::X509::Stack certs, Crypt::OpenSSL3::X509::Store store, Crypt::OpenSSL3::BIO indata, Crypt::OpenSSL3::BIO out, int flags)
2110
2111			Crypt::OpenSSL3::X509::Stack PKCS7_get_signers(Crypt::OpenSSL3::PKCS7 p7, Crypt::OpenSSL3::X509::Stack certs, int flags)
2112			POSTCALL:
2113	0	0	if (RETVAL)
2114	0		sk_X509_dup(RETVAL);
2115
2116			Crypt::OpenSSL3::PKCS7 PKCS7_encrypt(class, Crypt::OpenSSL3::X509::Stack certs, Crypt::OpenSSL3::BIO in, Crypt::OpenSSL3::Cipher cipher, int flags, const char* propq = NULL)
2117			C_ARGS: certs, in, cipher, flags, NULL, propq
2118
2119			bool PKCS7_decrypt(Crypt::OpenSSL3::PKCS7 p7, Crypt::OpenSSL3::PKey pkey, Crypt::OpenSSL3::X509 cert, Crypt::OpenSSL3::BIO data, int flags)
2120
2121			Crypt::OpenSSL3::ASN1::String PKCS7_get_octet_string(Crypt::OpenSSL3::PKCS7 p7);
2122
2123			bool PKCS7_type_is_signed(Crypt::OpenSSL3::PKCS7 a)
2124
2125			bool PKCS7_type_is_encrypted(Crypt::OpenSSL3::PKCS7 a)
2126
2127			bool PKCS7_type_is_enveloped(Crypt::OpenSSL3::PKCS7 a)
2128
2129			bool PKCS7_type_is_signedAndEnveloped(Crypt::OpenSSL3::PKCS7 a)
2130
2131			bool PKCS7_type_is_data(Crypt::OpenSSL3::PKCS7 a)
2132
2133			bool PKCS7_type_is_digest(Crypt::OpenSSL3::PKCS7 a)
2134
2135			bool PKCS7_type_is_other(Crypt::OpenSSL3::PKCS7 p7)
2136
2137
2138
2139			MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::SSL::Method PREFIX = SSL_Method_
2140
2141			Crypt::OpenSSL3::SSL::Method SSL_Method_TLS()
2142
2143			Crypt::OpenSSL3::SSL::Method SSL_Method_TLS_server()
2144
2145			Crypt::OpenSSL3::SSL::Method SSL_Method_TLS_client()
2146
2147			Crypt::OpenSSL3::SSL::Method SSL_Method_DTLS()
2148
2149			Crypt::OpenSSL3::SSL::Method SSL_Method_DTLS_server()
2150
2151			Crypt::OpenSSL3::SSL::Method SSL_Method_DTLS_client()
2152
2153			#if OPENSSL_VERSION_PREREQ(3, 2)
2154			Crypt::OpenSSL3::SSL::Method SSL_Method_QUIC_client()
2155
2156			Crypt::OpenSSL3::SSL::Method SSL_Method_QUIC_client_thread()
2157			#endif
2158
2159			#if OPENSSL_VERSION_PREREQ(3, 5)
2160			Crypt::OpenSSL3::SSL::Method SSL_Method_QUIC_server()
2161			#endif
2162
2163			MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::SSL::Context PREFIX = SSL_CTX_
2164
2165			Crypt::OpenSSL3::SSL::Context SSL_CTX_new(classname, Crypt::OpenSSL3::SSL::Method method = TLS_method())
2166			C_ARGS: method
2167
2168			long SSL_CTX_set_options(Crypt::OpenSSL3::SSL::Context ctx, long options)
2169
2170			long SSL_CTX_clear_options(Crypt::OpenSSL3::SSL::Context ctx, long options)
2171
2172			long SSL_CTX_get_options(Crypt::OpenSSL3::SSL::Context ctx)
2173
2174			void SSL_CTX_set_read_ahead(Crypt::OpenSSL3::SSL::Context ctx, bool yes)
2175
2176			bool SSL_CTX_get_read_ahead(Crypt::OpenSSL3::SSL::Context ctx)
2177
2178			bool SSL_CTX_set_session_id_context(Crypt::OpenSSL3::SSL::Context ctx, const unsigned char *sid_ctx, unsigned int length(sid_ctx))
2179
2180			long SSL_CTX_set_mode(Crypt::OpenSSL3::SSL::Context ctx, long mode)
2181
2182			long SSL_CTX_clear_mode(Crypt::OpenSSL3::SSL::Context ctx, long mode)
2183
2184			long SSL_CTX_get_mode(Crypt::OpenSSL3::SSL::Context ctx)
2185
2186			bool SSL_CTX_set_min_proto_version(Crypt::OpenSSL3::SSL::Context ctx, int version)
2187
2188			bool SSL_CTX_set_max_proto_version(Crypt::OpenSSL3::SSL::Context ctx, int version)
2189
2190			int SSL_CTX_get_min_proto_version(Crypt::OpenSSL3::SSL::Context ctx)
2191
2192			int SSL_CTX_get_max_proto_version(Crypt::OpenSSL3::SSL::Context ctx)
2193
2194			bool SSL_CTX_set_alpn_protos(Crypt::OpenSSL3::SSL::Context ctx, const unsigned char *protos, unsigned int length(protos))
2195
2196			Crypt::OpenSSL3::X509::Store SSL_CTX_get_cert_store(Crypt::OpenSSL3::SSL::Context ctx)
2197			POSTCALL:
2198	0		X509_STORE_up_ref(RETVAL);
2199
2200			void SSL_CTX_set_cert_store(Crypt::OpenSSL3::SSL::Context ctx, Crypt::OpenSSL3::X509::Store store)
2201			POSTCALL:
2202	0		X509_STORE_up_ref(store);
2203
2204			bool SSL_CTX_load_verify_locations(Crypt::OpenSSL3::SSL::Context ctx, const char CAfile, const char CApath)
2205
2206			bool SSL_CTX_load_verify_file(Crypt::OpenSSL3::SSL::Context ctx, const char *CAfile)
2207
2208			bool SSL_CTX_load_verify_dir(Crypt::OpenSSL3::SSL::Context ctx, const char *CApath)
2209
2210			bool SSL_CTX_load_verify_store(Crypt::OpenSSL3::SSL::Context ctx, const char *CAstore)
2211
2212			bool SSL_CTX_set_default_verify_paths(Crypt::OpenSSL3::SSL::Context ctx)
2213
2214			bool SSL_CTX_set_default_verify_dir(Crypt::OpenSSL3::SSL::Context ctx)
2215
2216			bool SSL_CTX_set_default_verify_file(Crypt::OpenSSL3::SSL::Context ctx)
2217
2218			bool SSL_CTX_use_certificate(Crypt::OpenSSL3::SSL::Context ctx, Crypt::OpenSSL3::X509 x)
2219
2220			bool SSL_CTX_use_certificate_ASN1(Crypt::OpenSSL3::SSL::Context ctx, int length(d), const unsigned char *d)
2221
2222			bool SSL_CTX_use_certificate_file(Crypt::OpenSSL3::SSL::Context ctx, const char *file, int type)
2223
2224			bool SSL_CTX_use_certificate_chain_file(Crypt::OpenSSL3::SSL::Context ctx, const char *file)
2225
2226			long SSL_CTX_add_extra_chain_cert(Crypt::OpenSSL3::SSL::Context ctx, Crypt::OpenSSL3::X509 x509)
2227
2228			long SSL_CTX_clear_extra_chain_certs(Crypt::OpenSSL3::SSL::Context ctx)
2229
2230			bool SSL_CTX_use_PrivateKey(Crypt::OpenSSL3::SSL::Context ctx, Crypt::OpenSSL3::PKey pkey)
2231
2232			bool SSL_CTX_use_PrivateKey_ASN1(Crypt::OpenSSL3::SSL::Context ctx, int pk, const unsigned char *d, long length(d))
2233			C_ARGS: pk, ctx, d, XSauto_length_of_d
2234
2235			bool SSL_CTX_use_PrivateKey_file(Crypt::OpenSSL3::SSL::Context ctx, const char *file, int type)
2236
2237			bool SSL_CTX_check_private_key(Crypt::OpenSSL3::SSL::Context ctx)
2238
2239			void SSL_CTX_set_verify(Crypt::OpenSSL3::SSL::Context ctx, int mode)
2240			C_ARGS: ctx, mode, NULL
2241
2242			void SSL_CTX_set_verify_depth(Crypt::OpenSSL3::SSL::Context ctx, int depth)
2243
2244			void SSL_CTX_set_post_handshake_auth(Crypt::OpenSSL3::SSL::Context ctx, int val)
2245
2246			bool SSL_CTX_set_cipher_list(Crypt::OpenSSL3::SSL::Context ctx, const char *str)
2247
2248			bool SSL_CTX_set_ciphersuites(Crypt::OpenSSL3::SSL::Context ctx, const char *str)
2249
2250			Crypt::OpenSSL3::X509::VerifyParam SSL_CTX_get_param(Crypt::OpenSSL3::SSL::Context ctx)
2251
2252			bool SSL_CTX_set_param(Crypt::OpenSSL3::SSL::Context ctx, Crypt::OpenSSL3::X509::VerifyParam vpm);
2253
2254			int SSL_CTX_add_client_CA(Crypt::OpenSSL3::SSL::Context ctx, Crypt::OpenSSL3::X509 cacert)
2255			POSTCALL:
2256	0		X509_up_ref(cacert);
2257
2258			bool SSL_CTX_add_session(Crypt::OpenSSL3::SSL::Context ctx, Crypt::OpenSSL3::SSL::Session c);
2259
2260			bool SSL_CTX_remove_session(Crypt::OpenSSL3::SSL::Context ctx, Crypt::OpenSSL3::SSL::Session c);
2261
2262			long SSL_CTX_sess_number(Crypt::OpenSSL3::SSL::Context ctx)
2263
2264			long SSL_CTX_sess_connect(Crypt::OpenSSL3::SSL::Context ctx)
2265
2266			long SSL_CTX_sess_connect_good(Crypt::OpenSSL3::SSL::Context ctx)
2267
2268			long SSL_CTX_sess_connect_renegotiate(Crypt::OpenSSL3::SSL::Context ctx)
2269
2270			long SSL_CTX_sess_accept(Crypt::OpenSSL3::SSL::Context ctx)
2271
2272			long SSL_CTX_sess_accept_good(Crypt::OpenSSL3::SSL::Context ctx)
2273
2274			long SSL_CTX_sess_accept_renegotiate(Crypt::OpenSSL3::SSL::Context ctx)
2275
2276			long SSL_CTX_sess_hits(Crypt::OpenSSL3::SSL::Context ctx)
2277
2278			long SSL_CTX_sess_cb_hits(Crypt::OpenSSL3::SSL::Context ctx)
2279
2280			long SSL_CTX_sess_misses(Crypt::OpenSSL3::SSL::Context ctx)
2281
2282			long SSL_CTX_sess_timeouts(Crypt::OpenSSL3::SSL::Context ctx)
2283
2284			long SSL_CTX_sess_cache_full(Crypt::OpenSSL3::SSL::Context ctx)
2285
2286			long SSL_CTX_sess_set_cache_size(Crypt::OpenSSL3::SSL::Context ctx, long t)
2287
2288			long SSL_CTX_sess_get_cache_size(Crypt::OpenSSL3::SSL::Context ctx)
2289
2290			int SSL_CTX_set_num_tickets(Crypt::OpenSSL3::SSL::Context ctx, size_t num_tickets)
2291
2292			size_t SSL_CTX_get_num_tickets(Crypt::OpenSSL3::SSL::Context ctx)
2293
2294			#if OPENSSL_VERSION_PREREQ(3, 5)
2295
2296			bool SSL_CTX_set_domain_flags(Crypt::OpenSSL3::SSL::Context ctx, uint64_t flags)
2297
2298			NO_OUTPUT bool SSL_CTX_get_domain_flags(Crypt::OpenSSL3::SSL::Context ctx, OUTLIST uint64_t flags)
2299			POSTCALL:
2300			if (!RETVAL)
2301			XSRETURN_UNDEF;
2302			#endif
2303
2304			MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::SSL PREFIX = SSL_
2305
2306			BOOT:
2307			{
2308	60		HV* stash = gv_stashpvs("Crypt::OpenSSL3::SSL", GV_ADD \| GV_ADDMULTI);
2309	60		CONSTANT2(SSL_, ERROR_NONE);
2310	60		CONSTANT2(SSL_, ERROR_ZERO_RETURN);
2311	60		CONSTANT2(SSL_, ERROR_WANT_READ);
2312	60		CONSTANT2(SSL_, ERROR_WANT_WRITE);
2313	60		CONSTANT2(SSL_, ERROR_WANT_CONNECT);
2314	60		CONSTANT2(SSL_, ERROR_WANT_ACCEPT);
2315	60		CONSTANT2(SSL_, ERROR_WANT_X509_LOOKUP);
2316	60		CONSTANT2(SSL_, ERROR_WANT_ASYNC);
2317	60		CONSTANT2(SSL_, ERROR_WANT_ASYNC_JOB);
2318	60		CONSTANT2(SSL_, ERROR_SYSCALL);
2319	60		CONSTANT2(SSL_, ERROR_SSL);
2320
2321	60		CONSTANT2(SSL_, VERIFY_NONE);
2322	60		CONSTANT2(SSL_, VERIFY_PEER);
2323	60		CONSTANT2(SSL_, VERIFY_FAIL_IF_NO_PEER_CERT);
2324	60		CONSTANT2(SSL_, VERIFY_CLIENT_ONCE);
2325	60		CONSTANT2(SSL_, VERIFY_POST_HANDSHAKE);
2326
2327	60		CONSTANT2(SSL_, MODE_ENABLE_PARTIAL_WRITE);
2328	60		CONSTANT2(SSL_, MODE_ACCEPT_MOVING_WRITE_BUFFER);
2329	60		CONSTANT2(SSL_, MODE_AUTO_RETRY);
2330	60		CONSTANT2(SSL_, MODE_RELEASE_BUFFERS);
2331	60		CONSTANT2(SSL_, MODE_SEND_FALLBACK_SCSV);
2332	60		CONSTANT2(SSL_, MODE_ASYNC);
2333
2334	60		CONSTANT2(SSL_, FILETYPE_PEM);
2335	60		CONSTANT2(SSL_, FILETYPE_ASN1);
2336
2337	60		CONSTANT2(, TLS1_VERSION);
2338	60		CONSTANT2(, TLS1_1_VERSION);
2339	60		CONSTANT2(, TLS1_2_VERSION);
2340	60		CONSTANT2(, TLS1_3_VERSION);
2341	60		CONSTANT2(, DTLS1_VERSION);
2342	60		CONSTANT2(, DTLS1_2_VERSION);
2343			#if OPENSSL_VERSION_PREREQ(3, 2)
2344			CONSTANT2(OSSL_, QUIC1_VERSION);
2345			CONSTANT2(SSL_, ACCEPT_STREAM_NO_BLOCK);
2346			CONSTANT2(SSL_, INCOMING_STREAM_POLICY_AUTO);
2347			CONSTANT2(SSL_, INCOMING_STREAM_POLICY_ACCEPT);
2348			CONSTANT2(SSL_, INCOMING_STREAM_POLICY_REJECT);
2349			CONSTANT2(SSL_, STREAM_FLAG_UNI);
2350			CONSTANT2(SSL_, STREAM_FLAG_NO_BLOCK);
2351			CONSTANT2(SSL_, STREAM_FLAG_ADVANCE);
2352			CONSTANT2(SSL_, STREAM_TYPE_NONE);
2353			CONSTANT2(SSL_, STREAM_TYPE_BIDI);
2354			CONSTANT2(SSL_, STREAM_TYPE_READ);
2355			CONSTANT2(SSL_, STREAM_TYPE_WRITE);
2356			#endif
2357			#if OPENSSL_VERSION_PREREQ(3, 5)
2358			CONSTANT2(SSL_, ACCEPT_CONNECTION_NO_BLOCK);
2359			CONSTANT2(SSL_, DOMAIN_FLAG_SINGLE_THREAD);
2360			CONSTANT2(SSL_, DOMAIN_FLAG_MULTI_THREAD);
2361			CONSTANT2(SSL_, DOMAIN_FLAG_THREAD_ASSISTED);
2362			CONSTANT2(SSL_, DOMAIN_FLAG_BLOCKING);
2363			CONSTANT2(SSL_, DOMAIN_FLAG_LEGACY_BLOCKING);
2364			#endif
2365			}
2366
2367			Crypt::OpenSSL3::SSL SSL_new(classname, Crypt::OpenSSL3::SSL::Context context)
2368			C_ARGS: context
2369
2370			Crypt::OpenSSL3::SSL::Method SSL_get_ssl_method(Crypt::OpenSSL3::SSL ssl)
2371
2372			Crypt::OpenSSL3::SSL::Context SSL_get_context(Crypt::OpenSSL3::SSL ssl)
2373			POSTCALL:
2374	0		SSL_CTX_up_ref(RETVAL);
2375
2376			NO_OUTPUT int SSL_get_event_timeout(Crypt::OpenSSL3::SSL s, OUTLIST struct timeval tv, OUTLIST Bool is_infinite)
2377			INIT:
2378	0		is_infinite = 0;
2379			POSTCALL:
2380	0	0	if (!RETVAL)
2381	0		XSRETURN_EMPTY;
2382
2383			bool SSL_handle_events(Crypt::OpenSSL3::SSL ssl)
2384
2385			long SSL_set_options(Crypt::OpenSSL3::SSL ssl, long options)
2386
2387			long SSL_clear_options(Crypt::OpenSSL3::SSL ssl, long options)
2388
2389			long SSL_get_options(Crypt::OpenSSL3::SSL ssl)
2390
2391			bool SSL_set_session_id_context(Crypt::OpenSSL3::SSL ssl, const unsigned char *sid_ctx, unsigned int length(sid_ctx))
2392
2393			long SSL_set_mode(Crypt::OpenSSL3::SSL ssl, long mode)
2394
2395			long SSL_clear_mode(Crypt::OpenSSL3::SSL ssl, long mode)
2396
2397			long SSL_get_mode(Crypt::OpenSSL3::SSL ssl)
2398
2399			bool SSL_set_min_proto_version(Crypt::OpenSSL3::SSL ssl, int version)
2400
2401			bool SSL_set_max_proto_version(Crypt::OpenSSL3::SSL ssl, int version)
2402
2403			int SSL_get_min_proto_version(Crypt::OpenSSL3::SSL ssl)
2404
2405			int SSL_get_max_proto_version(Crypt::OpenSSL3::SSL ssl)
2406
2407			void SSL_set_security_level(Crypt::OpenSSL3::SSL s, int level)
2408
2409			int SSL_get_security_level(Crypt::OpenSSL3::SSL s)
2410
2411			bool SSL_set_alpn_protos(Crypt::OpenSSL3::SSL ssl, ...)
2412			CODE:
2413	0		SV* buffer = sv_2mortal(newSVpvs(""));
2414			static const char pattern[] = "(C/a)*";
2415	0		packlist(buffer, pattern, pattern + sizeof pattern - 1, &ST(1), &ST(items));
2416			STRLEN raw_len;
2417	0		const char* raw = SvPVbyte(buffer, raw_len);
2418	0	0	RETVAL = SSL_set_alpn_protos(ssl, (unsigned char*)raw, raw_len);
2419			OUTPUT: RETVAL
2420
2421			bool SSL_use_certificate(Crypt::OpenSSL3::SSL ssl, Crypt::OpenSSL3::X509 x)
2422
2423			bool SSL_use_certificate_ASN1(Crypt::OpenSSL3::SSL ssl, const unsigned char *d, int length(d))
2424
2425			bool SSL_use_certificate_file(Crypt::OpenSSL3::SSL ssl, const char *file, int type)
2426
2427			bool SSL_use_certificate_chain_file(Crypt::OpenSSL3::SSL ssl, const char *file)
2428
2429			bool SSL_use_PrivateKey(Crypt::OpenSSL3::SSL ssl, Crypt::OpenSSL3::PKey pkey)
2430
2431			bool SSL_use_PrivateKey_ASN1(Crypt::OpenSSL3::SSL ssl, int pk, const unsigned char *d, long length(d))
2432			C_ARGS: pk, ssl, d, XSauto_length_of_d
2433
2434			bool SSL_use_PrivateKey_file(Crypt::OpenSSL3::SSL ssl, const char *file, int type)
2435
2436			bool SSL_check_private_key(Crypt::OpenSSL3::SSL ssl)
2437
2438			void SSL_set_verify(Crypt::OpenSSL3::SSL ssl, int mode)
2439			C_ARGS: ssl, mode, NULL
2440
2441			void SSL_set_verify_depth(Crypt::OpenSSL3::SSL ssl, int depth)
2442
2443			Crypt::OpenSSL3::X509::VerifyResult SSL_get_verify_result(Crypt::OpenSSL3::SSL ssl);
2444
2445			void SSL_set_post_handshake_auth(Crypt::OpenSSL3::SSL ssl, int val)
2446
2447			bool SSL_set_cipher_list(Crypt::OpenSSL3::SSL ssl, const char *str)
2448
2449			bool SSL_set_ciphersuites(Crypt::OpenSSL3::SSL ssl, const char *str)
2450
2451			const char *SSL_get_cipher_list(Crypt::OpenSSL3::SSL ssl, int priority)
2452			POSTCALL:
2453	0	0	if (!RETVAL)
2454	0		XSRETURN_UNDEF;
2455
2456			Crypt::OpenSSL3::X509::VerifyParam SSL_get_param(Crypt::OpenSSL3::SSL ssl)
2457
2458			bool SSL_set_param(Crypt::OpenSSL3::SSL ssl, Crypt::OpenSSL3::X509::VerifyParam vpm);
2459
2460			int SSL_add_client_CA(Crypt::OpenSSL3::SSL ssl, Crypt::OpenSSL3::X509 cacert)
2461			POSTCALL:
2462	0		X509_up_ref(cacert);
2463
2464			bool SSL_verify_client_post_handshake(Crypt::OpenSSL3::SSL ssl)
2465
2466			int SSL_get_error(Crypt::OpenSSL3::SSL ssl, int ret)
2467
2468			bool SSL_set_tlsext_host_name(Crypt::OpenSSL3::SSL s, const char *name)
2469
2470			const char* SSL_get_servername(Crypt::OpenSSL3::SSL s, int type)
2471
2472			int SSL_get_servername_type(Crypt::OpenSSL3::SSL s)
2473
2474			bool SSL_set_host(Crypt::OpenSSL3::SSL s, const char *hostname)
2475
2476			#if OPENSSL_VERSION_PREREQ(4, 0)
2477			bool SSL_set_dnsname(Crypt::OpenSSL3::SSL s, const char *hostname)
2478
2479			bool SSL_set_ipaddr(Crypt::OpenSSL3::SSL s, const char *hostname)
2480			#endif
2481
2482			int SSL_connect(Crypt::OpenSSL3::SSL ssl)
2483
2484			int SSL_accept(Crypt::OpenSSL3::SSL ssl)
2485
2486			int SSL_clear(Crypt::OpenSSL3::SSL ssl)
2487
2488			int SSL_do_handshake(Crypt::OpenSSL3::SSL ssl)
2489
2490			void SSL_set_connect_state(Crypt::OpenSSL3::SSL ssl)
2491
2492			void SSL_set_accept_state(Crypt::OpenSSL3::SSL ssl)
2493
2494			bool SSL_is_server(Crypt::OpenSSL3::SSL ssl)
2495
2496			int SSL_read(Crypt::OpenSSL3::SSL ssl, SV* buffer, size_t size)
2497			INTERFACE: SSL_read SSL_peek
2498			INIT:
2499	1		char* ptr = grow_buffer(buffer, size);
2500			C_ARGS: ssl, ptr, size
2501			POSTCALL:
2502	1	50	if (RETVAL > 0)
2503	1		set_buffer_length(buffer, RETVAL);
2504
2505			int SSL_write(Crypt::OpenSSL3::SSL ssl, const char* buf, int length(buf))
2506
2507			ssize_t SSL_sendfile(Crypt::OpenSSL3::SSL s, int fd, uint64_t offset, size_t size, int flags)
2508
2509			int SSL_shutdown(Crypt::OpenSSL3::SSL ssl)
2510
2511			bool SSL_set_fd(Crypt::OpenSSL3::SSL ssl, int fd)
2512
2513			bool SSL_set_rfd(Crypt::OpenSSL3::SSL ssl, int fd)
2514
2515			bool SSL_set_wfd(Crypt::OpenSSL3::SSL ssl, int fd)
2516
2517			int SSL_get_fd(Crypt::OpenSSL3::SSL ssl)
2518
2519			int SSL_get_rfd(Crypt::OpenSSL3::SSL ssl)
2520
2521			int SSL_get_wfd(Crypt::OpenSSL3::SSL ssl)
2522
2523			void SSL_set_rbio(Crypt::OpenSSL3::SSL s, Crypt::OpenSSL3::BIO bio)
2524			INTERFACE: SSL_set_rbio SSL_set_wbio
2525			INIT:
2526	4		BIO_up_ref(bio);
2527
2528			Crypt::OpenSSL3::BIO SSL_get_rbio(Crypt::OpenSSL3::SSL ssl)
2529			INTERFACE: SSL_get_rbio SSL_get_wbio
2530			POSTCALL:
2531	0	0	if (RETVAL)
2532	0		BIO_up_ref(RETVAL);
2533			else
2534	0		XSRETURN_UNDEF;
2535
2536			void SSL_set_read_ahead(Crypt::OpenSSL3::SSL s, bool yes)
2537
2538			bool SSL_get_read_ahead(Crypt::OpenSSL3::SSL s)
2539
2540			Crypt::OpenSSL3::SSL::Session SSL_get_session(Crypt::OpenSSL3::SSL ssl)
2541			POSTCALL:
2542	0	0	if (RETVAL)
2543	0		SSL_SESSION_up_ref(RETVAL);
2544			else
2545	0		XSRETURN_UNDEF;
2546
2547			bool SSL_set_session(Crypt::OpenSSL3::SSL ssl, Crypt::OpenSSL3::SSL::Session session)
2548
2549			bool SSL_session_reused(Crypt::OpenSSL3::SSL ssl)
2550
2551			Crypt::OpenSSL3::X509 SSL_get_certificate(Crypt::OpenSSL3::SSL ssl)
2552			INTERFACE: SSL_get_certificate SSL_get_peer_certificate
2553			POSTCALL:
2554	0	0	if (RETVAL)
2555	0		X509_up_ref(RETVAL);
2556			else
2557	0		XSRETURN_UNDEF;
2558
2559			Crypt::OpenSSL3::PKey SSL_get_privatekey(Crypt::OpenSSL3::SSL ssl)
2560			POSTCALL:
2561	0	0	if (RETVAL)
2562	0		EVP_PKEY_up_ref(RETVAL);
2563			else
2564	0		XSRETURN_UNDEF;
2565
2566			Crypt::OpenSSL3::SSL::Cipher SSL_get_current_cipher(Crypt::OpenSSL3::SSL ssl)
2567			INTERFACE: SSL_get_current_cipher SSL_get_pending_cipher
2568			POSTCALL:
2569	0	0	if (!RETVAL)
2570	0		XSRETURN_UNDEF;
2571
2572			int SSL_client_version(Crypt::OpenSSL3::SSL s)
2573
2574			const char *SSL_get_version(Crypt::OpenSSL3::SSL ssl)
2575
2576			bool SSL_is_dtls(Crypt::OpenSSL3::SSL ssl)
2577
2578			bool SSL_is_tls(Crypt::OpenSSL3::SSL ssl)
2579
2580			bool SSL_is_quic(Crypt::OpenSSL3::SSL ssl)
2581
2582			bool SSL_in_init(Crypt::OpenSSL3::SSL s)
2583
2584			bool SSL_in_before(Crypt::OpenSSL3::SSL s)
2585
2586			bool SSL_is_init_finished(Crypt::OpenSSL3::SSL s)
2587
2588			bool SSL_in_connect_init(Crypt::OpenSSL3::SSL s)
2589
2590			bool SSL_in_accept_init(Crypt::OpenSSL3::SSL s)
2591
2592			int SSL_pending(Crypt::OpenSSL3::SSL ssl)
2593
2594			bool SSL_has_pending(Crypt::OpenSSL3::SSL s)
2595
2596			int SSL_version(Crypt::OpenSSL3::SSL s)
2597
2598			const char *SSL_state_string(Crypt::OpenSSL3::SSL ssl)
2599
2600			const char *SSL_state_string_long(Crypt::OpenSSL3::SSL ssl)
2601
2602			const char *SSL_rstate_string(Crypt::OpenSSL3::SSL ssl)
2603
2604			const char *SSL_rstate_string_long(Crypt::OpenSSL3::SSL ssl)
2605
2606			int SSL_set_num_tickets(Crypt::OpenSSL3::SSL s, size_t num_tickets)
2607
2608			size_t SSL_get_num_tickets(Crypt::OpenSSL3::SSL s)
2609
2610			bool SSL_new_session_ticket(Crypt::OpenSSL3::SSL s)
2611
2612			NO_OUTPUT size_t SSL_get_finished(Crypt::OpenSSL3::SSL ssl, OUTLIST SV* result)
2613			size_t max_size = EVP_MAX_MD_SIZE;
2614			INTERFACE: SSL_get_finished SSL_get_peer_finished
2615			INIT:
2616	0		unsigned char* ptr = make_buffer(&result, max_size);
2617			C_ARGS: ssl, ptr, max_size
2618			POSTCALL:
2619	0	0	if (RETVAL)
2620	0		set_buffer_length(result, RETVAL);
2621
2622			void SSL_get_alpn_selected(Crypt::OpenSSL3::SSL s, OUTLIST SV* result)
2623			const unsigned char* ptr = NULL;
2624			unsigned int len = 0;
2625			C_ARGS: s, &ptr, &len
2626			POSTCALL:
2627	0		result = newSVpvn((char*)ptr, len);
2628
2629			#if OPENSSL_VERSION_PREREQ(3, 2)
2630
2631			bool SSL_set_blocking_mode(Crypt::OpenSSL3::SSL s, int blocking)
2632
2633			Success SSL_get_blocking_mode(Crypt::OpenSSL3::SSL s)
2634
2635			Crypt::OpenSSL3::SSL SSL_new_stream(Crypt::OpenSSL3::SSL ssl, uint64_t flags)
2636
2637			bool SSL_set_incoming_stream_policy(Crypt::OpenSSL3::SSL conn, int policy, uint64_t app_error_code = 0)
2638
2639			Crypt::OpenSSL3::SSL SSL_accept_stream(Crypt::OpenSSL3::SSL ssl, uint64_t flags)
2640
2641			size_t SSL_get_accept_stream_queue_len(Crypt::OpenSSL3::SSL ssl)
2642
2643			bool SSL_set_default_stream_mode(Crypt::OpenSSL3::SSL conn, unsigned mode)
2644
2645			bool SSL_stream_conclude(Crypt::OpenSSL3::SSL s, uint64_t flags)
2646
2647			bool SSL_stream_reset(Crypt::OpenSSL3::SSL ssl)
2648			C_ARGS: ssl, NULL, 0
2649
2650			int SSL_get_rpoll_descriptor(Crypt::OpenSSL3::SSL s, Crypt::OpenSSL3::BIO::PollDescriptor desc)
2651
2652			int SSL_get_wpoll_descriptor(Crypt::OpenSSL3::SSL s, Crypt::OpenSSL3::BIO::PollDescriptor desc)
2653
2654			bool SSL_net_read_desired(Crypt::OpenSSL3::SSL s)
2655
2656			bool SSL_net_write_desired(Crypt::OpenSSL3::SSL s)
2657
2658			Crypt::OpenSSL3::SSL SSL_get_connection(Crypt::OpenSSL3::SSL ssl)
2659			POSTCALL:
2660			SSL_up_ref(RETVAL);
2661
2662			bool SSL_is_connection(Crypt::OpenSSL3::SSL ssl)
2663
2664			uint64_t SSL_get_stream_id(Crypt::OpenSSL3::SSL ssl)
2665			POSTCALL:
2666			if (RETVAL == UINT64_MAX)
2667			XSRETURN_UNDEF;
2668
2669			int SSL_get_stream_type(Crypt::OpenSSL3::SSL ssl)
2670
2671			Success SSL_is_stream_local(Crypt::OpenSSL3::SSL ssl)
2672
2673			bool SSL_set_initial_peer_addr(Crypt::OpenSSL3::SSL s, Crypt::OpenSSL3::BIO::Address addr)
2674
2675			#endif
2676
2677
2678			#if OPENSSL_VERSION_PREREQ(3, 5)
2679
2680			Crypt::OpenSSL3::SSL SSL_new_listener(classname, Crypt::OpenSSL3::SSL::Context ctx, uint64_t flags)
2681			C_ARGS: ctx, flags
2682
2683			Crypt::OpenSSL3::SSL SSL_new_listener_from(Crypt::OpenSSL3::SSL ssl, uint64_t flags)
2684
2685			bool SSL_is_listener(Crypt::OpenSSL3::SSL ssl)
2686
2687			Crypt::OpenSSL3::SSL SSL_get_listener(Crypt::OpenSSL3::SSL ssl)
2688			INTERFACE: SSL_get_listener SSL_get_domain
2689			POSTCALL:
2690			if (RETVAL)
2691			SSL_up_ref(RETVAL);
2692			else
2693			XSRETURN_UNDEF;
2694
2695			bool SSL_listen(Crypt::OpenSSL3::SSL ssl)
2696
2697			Crypt::OpenSSL3::SSL SSL_accept_connection(Crypt::OpenSSL3::SSL ssl, uint64_t flags)
2698
2699			size_t SSL_get_accept_connection_queue_len(Crypt::OpenSSL3::SSL ssl)
2700
2701			Crypt::OpenSSL3::SSL SSL_new_from_listener(Crypt::OpenSSL3::SSL ssl, uint64_t flags)
2702
2703			Crypt::OpenSSL3::SSL SSL_new_domain(Crypt::OpenSSL3::SSL::Context ctx, uint64_t flags)
2704
2705			bool SSL_is_domain(Crypt::OpenSSL3::SSL ssl)
2706
2707			NO_OUTPUT int SSL_get_domain_flags(Crypt::OpenSSL3::SSL ssl, OUTLIST uint64_t flags)
2708			POSTCALL:
2709			if (!RETVAL)
2710			XSRETURN_UNDEF;
2711
2712			#endif
2713
2714
2715			MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::SSL::Cipher PREFIX = SSL_CIPHER_
2716
2717			const char *SSL_CIPHER_get_name(Crypt::OpenSSL3::SSL::Cipher cipher)
2718
2719			const char *SSL_CIPHER_standard_name(Crypt::OpenSSL3::SSL::Cipher cipher)
2720
2721			NO_OUTPUT int SSL_CIPHER_get_bits(Crypt::OpenSSL3::SSL::Cipher cipher, OUTLIST int alg_bits)
2722			POSTCALL:
2723	0	0	if (!RETVAL)
2724	0		alg_bits = 0;
2725
2726			const char *SSL_CIPHER_get_version(Crypt::OpenSSL3::SSL::Cipher cipher)
2727
2728			NO_OUTPUT char SSL_CIPHER_description(Crypt::OpenSSL3::SSL::Cipher cipher, OUTLIST SV description, int length = 128)
2729			INIT:
2730	0		char* ptr = (char*)make_buffer(&description, length);
2731			C_ARGS: cipher, ptr, length
2732			POSTCALL:
2733	0	0	if (RETVAL)
2734	0		set_buffer_length(description, strlen(ptr));
2735
2736			Crypt::OpenSSL3::NID SSL_CIPHER_get_cipher_nid(Crypt::OpenSSL3::SSL::Cipher c)
2737
2738			Crypt::OpenSSL3::NID SSL_CIPHER_get_digest_nid(Crypt::OpenSSL3::SSL::Cipher c)
2739
2740			Crypt::OpenSSL3::MD SSL_CIPHER_get_handshake_digest(Crypt::OpenSSL3::SSL::Cipher c)
2741			POSTCALL:
2742	0	0	if (RETVAL)
2743	0		EVP_MD_up_ref(RETVAL);
2744			else
2745	0		XSRETURN_UNDEF;
2746
2747			Crypt::OpenSSL3::NID SSL_CIPHER_get_kx_nid(Crypt::OpenSSL3::SSL::Cipher c)
2748
2749			Crypt::OpenSSL3::NID SSL_CIPHER_get_auth_nid(Crypt::OpenSSL3::SSL::Cipher c)
2750
2751			bool SSL_CIPHER_is_aead(Crypt::OpenSSL3::SSL::Cipher c)
2752
2753			unsigned SSL_CIPHER_get_id(Crypt::OpenSSL3::SSL::Cipher c)
2754
2755			unsigned SSL_CIPHER_get_protocol_id(Crypt::OpenSSL3::SSL::Cipher c)
2756
2757
2758
2759			MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::SSL::Session PREFIX = SSL_SESSION_
2760
2761			Crypt::OpenSSL3::SSL::Session SSL_SESSION_new(class)
2762			C_ARGS:
2763
2764			Crypt::OpenSSL3::SSL::Session SSL_SESSION_read_der(class, Crypt::OpenSSL3::BIO bio)
2765			C_ARGS: bio, NULL
2766			POSTCALL:
2767	0	0	if (!RETVAL)
2768	0		XSRETURN_UNDEF;
2769
2770			bool SSL_SESSION_write_der(Crypt::OpenSSL3::SSL::Session x, Crypt::OpenSSL3::BIO bio)
2771			C_ARGS: bio, x
2772
2773			Crypt::OpenSSL3::SSL::Session SSL_SESSION_dup(Crypt::OpenSSL3::SSL::Session s)
2774
2775			long SSL_SESSION_get_timeout(Crypt::OpenSSL3::SSL::Session s)
2776
2777			long SSL_SESSION_set_timeout(Crypt::OpenSSL3::SSL::Session s, long t)
2778
2779			int SSL_SESSION_get_protocol_version(Crypt::OpenSSL3::SSL::Session s)
2780
2781			int SSL_SESSION_set_protocol_version(Crypt::OpenSSL3::SSL::Session s, int version)
2782
2783			time_t SSL_SESSION_get_time(Crypt::OpenSSL3::SSL::Session s)
2784
2785			time_t SSL_SESSION_set_time(Crypt::OpenSSL3::SSL::Session s, time_t t)
2786
2787			const char *SSL_SESSION_get_hostname(Crypt::OpenSSL3::SSL::Session s)
2788
2789			bool SSL_SESSION_set_hostname(Crypt::OpenSSL3::SSL::Session s, const char *hostname)
2790
2791			void SSL_SESSION_get_alpn_selected(Crypt::OpenSSL3::SSL::Session s, OUTLIST SV* result)
2792			const unsigned char* ptr = NULL;
2793			size_t len = 0;
2794			C_ARGS: s, &ptr, &len
2795			POSTCALL:
2796	0		result = newSVpvn((char*)ptr, len);
2797
2798			bool SSL_SESSION_set_alpn_selected(Crypt::OpenSSL3::SSL::Session s, const unsigned char *alpn, size_t length(alpn))
2799
2800			Crypt::OpenSSL3::SSL::Cipher SSL_SESSION_get_cipher(Crypt::OpenSSL3::SSL::Session s)
2801
2802			bool SSL_SESSION_set_cipher(Crypt::OpenSSL3::SSL::Session s, Crypt::OpenSSL3::SSL::Cipher cipher)
2803
2804			bool SSL_SESSION_has_ticket(Crypt::OpenSSL3::SSL::Session s)
2805
2806			unsigned long SSL_SESSION_get_ticket_lifetime_hint(Crypt::OpenSSL3::SSL::Session s)
2807
2808			void SSL_SESSION_get_ticket(Crypt::OpenSSL3::SSL::Session s, OUTLIST SV* result)
2809			const unsigned char* ptr = NULL;
2810			size_t len = 0;
2811			C_ARGS: s, &ptr, &len
2812			POSTCALL:
2813	0		result = newSVpvn((char*)ptr, len);
2814
2815			unsigned SSL_SESSION_get_max_early_data(Crypt::OpenSSL3::SSL::Session s)
2816
2817			bool SSL_SESSION_set_max_early_data(Crypt::OpenSSL3::SSL::Session s, unsigned max_early_data)
2818
2819			Crypt::OpenSSL3::X509 SSL_SESSION_get_peer(Crypt::OpenSSL3::SSL::Session session)
2820			POSTCALL:
2821	0	0	if (RETVAL)
2822	0		X509_up_ref(RETVAL);
2823			else
2824	0		XSRETURN_UNDEF;
2825
2826			bool SSL_SESSION_set_id_context(Crypt::OpenSSL3::SSL::Session s, const unsigned char *sid_ctx, unsigned int length(sid_ctx))
2827
2828			bool SSL_SESSION_set_id(Crypt::OpenSSL3::SSL::Session s, const unsigned char *sid, unsigned int length(sid))
2829
2830			bool SSL_SESSION_is_resumable(Crypt::OpenSSL3::SSL::Session s)
2831
2832			NO_OUTPUT const unsigned char SSL_SESSION_get_id(Crypt::OpenSSL3::SSL::Session s, OUTLIST SV result)
2833			INTERFACE: SSL_SESSION_get_id SSL_SESSION_get_id_context
2834			INIT:
2835	0		unsigned int len = 0;
2836			C_ARGS: s, &len
2837			POSTCALL:
2838	0		result = newSVpvn((char*)RETVAL, len);
2839
2840			unsigned int SSL_SESSION_get_compress_id(Crypt::OpenSSL3::SSL::Session s)
2841
2842			bool SSL_SESSION_print(Crypt::OpenSSL3::BIO fp, Crypt::OpenSSL3::SSL::Session ses)
2843
2844			bool SSL_SESSION_print_keylog(Crypt::OpenSSL3::BIO bp, Crypt::OpenSSL3::SSL::Session x)
2845
2846
2847			MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::Timestamp::Request PREFIX = TS_REQ_
2848
2849			Crypt::OpenSSL3::Timestamp::Request TS_REQ_new(class)
2850			C_ARGS:
2851
2852			bool TS_REQ_set_version(Crypt::OpenSSL3::Timestamp::Request a, long version)
2853
2854			long TS_REQ_get_version(Crypt::OpenSSL3::Timestamp::Request a)
2855
2856			bool TS_REQ_set_msg_imprint(Crypt::OpenSSL3::Timestamp::Request a, Crypt::OpenSSL3::Timestamp::Imprint msg_imprint)
2857
2858			Crypt::OpenSSL3::Timestamp::Imprint TS_REQ_get_msg_imprint(Crypt::OpenSSL3::Timestamp::Request a)
2859
2860			bool TS_REQ_set_policy_id(Crypt::OpenSSL3::Timestamp::Request a, Crypt::OpenSSL3::ASN1::Object policy)
2861
2862			Crypt::OpenSSL3::ASN1::Object TS_REQ_get_policy_id(Crypt::OpenSSL3::Timestamp::Request a)
2863
2864			bool TS_REQ_set_nonce(Crypt::OpenSSL3::Timestamp::Request a, Crypt::OpenSSL3::ASN1::Integer nonce)
2865
2866			Crypt::OpenSSL3::ASN1::Integer TS_REQ_get_nonce(Crypt::OpenSSL3::Timestamp::Request a)
2867
2868			bool TS_REQ_set_cert_req(Crypt::OpenSSL3::Timestamp::Request a, int cert_req)
2869
2870			int TS_REQ_get_cert_req(Crypt::OpenSSL3::Timestamp::Request a)
2871
2872			# STACK_OF(X509_EXTENSION) *TS_REQ_get_exts(Crypt::OpenSSL3::Timestamp::Request a)
2873
2874			int TS_REQ_get_ext_count(Crypt::OpenSSL3::Timestamp::Request a)
2875
2876			int TS_REQ_get_ext_by_NID(Crypt::OpenSSL3::Timestamp::Request a, Crypt::OpenSSL3::NID nid, int lastpos)
2877
2878			int TS_REQ_get_ext_by_OBJ(Crypt::OpenSSL3::Timestamp::Request a, Crypt::OpenSSL3::ASN1::Object obj, int lastpos)
2879
2880			int TS_REQ_get_ext_by_critical(Crypt::OpenSSL3::Timestamp::Request a, int crit, int lastpos)
2881
2882			Crypt::OpenSSL3::X509::Extension TS_REQ_get_ext(Crypt::OpenSSL3::Timestamp::Request a, int loc)
2883
2884			Crypt::OpenSSL3::X509::Extension TS_REQ_delete_ext(Crypt::OpenSSL3::Timestamp::Request a, int loc)
2885
2886			bool TS_REQ_add_ext(Crypt::OpenSSL3::Timestamp::Request a, Crypt::OpenSSL3::X509::Extension ex, int loc)
2887
2888			PrintRet TS_REQ_print(Crypt::OpenSSL3::Timestamp::Request a, Crypt::OpenSSL3::BIO bio)
2889
2890			Crypt::OpenSSL3::Timestamp::Request TS_REQ_read_der(class, Crypt::OpenSSL3::BIO bio)
2891			C_ARGS: bio, NULL
2892			POSTCALL:
2893	0	0	if (!RETVAL)
2894	0		XSRETURN_UNDEF;
2895
2896			bool TS_REQ_write_der(Crypt::OpenSSL3::Timestamp::Request x, Crypt::OpenSSL3::BIO bio)
2897			C_ARGS: bio, x
2898
2899
2900			MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::Timestamp::Imprint PREFIX = TS_MSG_IMPRINT_
2901
2902			Crypt::OpenSSL3::Timestamp::Imprint TS_MSG_IMPRINT_new(class)
2903			C_ARGS:
2904
2905			bool TS_MSG_IMPRINT_set_algo(Crypt::OpenSSL3::Timestamp::Imprint a, Crypt::OpenSSL3::X509::Algorithm alg)
2906
2907			Crypt::OpenSSL3::X509::Algorithm TS_MSG_IMPRINT_get_algo(Crypt::OpenSSL3::Timestamp::Imprint a)
2908
2909			bool TS_MSG_IMPRINT_set_msg(Crypt::OpenSSL3::Timestamp::Imprint a, unsigned char *d, int length(d))
2910
2911			Crypt::OpenSSL3::ASN1::String TS_MSG_IMPRINT_get_msg(Crypt::OpenSSL3::Timestamp::Imprint a)
2912
2913			PrintRet TS_MSG_IMPRINT_print(Crypt::OpenSSL3::Timestamp::Imprint a, Crypt::OpenSSL3::BIO bio)
2914
2915			Crypt::OpenSSL3::Timestamp::Imprint TS_MSG_IMPRINT_read_der(class, Crypt::OpenSSL3::BIO bio)
2916			C_ARGS: bio, NULL
2917			POSTCALL:
2918	0	0	if (!RETVAL)
2919	0		XSRETURN_UNDEF;
2920
2921			bool TS_MSG_IMPRINT_write_der(Crypt::OpenSSL3::Timestamp::Imprint x, Crypt::OpenSSL3::BIO bio)
2922			C_ARGS: bio, x
2923
2924
2925			MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::Timestamp::TokenInfo PREFIX = TS_TST_INFO_
2926
2927			Crypt::OpenSSL3::Timestamp::TokenInfo TS_TST_INFO_new(class)
2928			C_ARGS:
2929
2930			bool TS_TST_INFO_set_version(Crypt::OpenSSL3::Timestamp::TokenInfo a, long version)
2931
2932			long TS_TST_INFO_get_version(Crypt::OpenSSL3::Timestamp::TokenInfo a)
2933
2934			bool TS_TST_INFO_set_policy_id(Crypt::OpenSSL3::Timestamp::TokenInfo a, Crypt::OpenSSL3::ASN1::Object policy_id)
2935			C_ARGS: a, (ASN1_OBJECT*)policy_id
2936
2937			Crypt::OpenSSL3::ASN1::Object TS_TST_INFO_get_policy_id(Crypt::OpenSSL3::Timestamp::TokenInfo a)
2938
2939			bool TS_TST_INFO_set_msg_imprint(Crypt::OpenSSL3::Timestamp::TokenInfo a, Crypt::OpenSSL3::Timestamp::Imprint msg_imprint)
2940
2941			Crypt::OpenSSL3::Timestamp::Imprint TS_TST_INFO_get_msg_imprint(Crypt::OpenSSL3::Timestamp::TokenInfo a)
2942
2943			bool TS_TST_INFO_set_serial(Crypt::OpenSSL3::Timestamp::TokenInfo a, Crypt::OpenSSL3::ASN1::Integer serial)
2944
2945			Crypt::OpenSSL3::ASN1::Integer TS_TST_INFO_get_serial(Crypt::OpenSSL3::Timestamp::TokenInfo a)
2946
2947			bool TS_TST_INFO_set_time(Crypt::OpenSSL3::Timestamp::TokenInfo a, Crypt::OpenSSL3::ASN1::Time::Generalized gtime)
2948
2949			Crypt::OpenSSL3::ASN1::Time::Generalized TS_TST_INFO_get_time(Crypt::OpenSSL3::Timestamp::TokenInfo a)
2950
2951			bool TS_TST_INFO_set_accuracy(Crypt::OpenSSL3::Timestamp::TokenInfo a, Crypt::OpenSSL3::Timestamp::Accuracy accuracy)
2952
2953			Crypt::OpenSSL3::Timestamp::Accuracy TS_TST_INFO_get_accuracy(Crypt::OpenSSL3::Timestamp::TokenInfo a)
2954
2955			bool TS_TST_INFO_set_ordering(Crypt::OpenSSL3::Timestamp::TokenInfo a, int ordering)
2956
2957			int TS_TST_INFO_get_ordering(Crypt::OpenSSL3::Timestamp::TokenInfo a)
2958
2959			bool TS_TST_INFO_set_nonce(Crypt::OpenSSL3::Timestamp::TokenInfo a, Crypt::OpenSSL3::ASN1::Integer nonce)
2960
2961			Crypt::OpenSSL3::ASN1::Integer TS_TST_INFO_get_nonce(Crypt::OpenSSL3::Timestamp::TokenInfo a)
2962
2963			bool TS_TST_INFO_set_tsa(Crypt::OpenSSL3::Timestamp::TokenInfo a, Crypt::OpenSSL3::X509::GeneralName tsa)
2964
2965			Crypt::OpenSSL3::X509::GeneralName TS_TST_INFO_get_tsa(Crypt::OpenSSL3::Timestamp::TokenInfo a)
2966
2967			int TS_TST_INFO_get_ext_count(Crypt::OpenSSL3::Timestamp::TokenInfo a)
2968
2969			int TS_TST_INFO_get_ext_by_NID(Crypt::OpenSSL3::Timestamp::TokenInfo a, Crypt::OpenSSL3::NID nid, int lastpos)
2970
2971			int TS_TST_INFO_get_ext_by_OBJ(Crypt::OpenSSL3::Timestamp::TokenInfo a, Crypt::OpenSSL3::ASN1::Object obj, int lastpos)
2972
2973			int TS_TST_INFO_get_ext_by_critical(Crypt::OpenSSL3::Timestamp::TokenInfo a, int crit, int lastpos)
2974
2975			Crypt::OpenSSL3::X509::Extension TS_TST_INFO_get_ext(Crypt::OpenSSL3::Timestamp::TokenInfo a, int loc)
2976
2977			Crypt::OpenSSL3::X509::Extension TS_TST_INFO_delete_ext(Crypt::OpenSSL3::Timestamp::TokenInfo a, int loc)
2978
2979			bool TS_TST_INFO_add_ext(Crypt::OpenSSL3::Timestamp::TokenInfo a, Crypt::OpenSSL3::X509::Extension ex, int loc)
2980
2981			PrintRet TS_TST_INFO_print(Crypt::OpenSSL3::Timestamp::TokenInfo a, Crypt::OpenSSL3::BIO bio)
2982
2983			Crypt::OpenSSL3::Timestamp::TokenInfo TS_TST_INFO_read_der(class, Crypt::OpenSSL3::BIO bio)
2984			C_ARGS: bio, NULL
2985			POSTCALL:
2986	0	0	if (!RETVAL)
2987	0		XSRETURN_UNDEF;
2988
2989			bool TS_TST_INFO_write_der(Crypt::OpenSSL3::Timestamp::TokenInfo x, Crypt::OpenSSL3::BIO bio)
2990			C_ARGS: bio, x
2991
2992			MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::Timestamp::Response PREFIX = TS_RESP_
2993
2994			Crypt::OpenSSL3::Timestamp::Response TS_RESP_new(class)
2995			C_ARGS:
2996
2997			bool TS_RESP_set_status_info(Crypt::OpenSSL3::Timestamp::Response a, Crypt::OpenSSL3::Timestamp::StatusInfo info)
2998
2999			Crypt::OpenSSL3::Timestamp::StatusInfo TS_RESP_get_status_info(Crypt::OpenSSL3::Timestamp::Response a)
3000
3001			Crypt::OpenSSL3::Timestamp::TokenInfo TS_RESP_get_tst_info(Crypt::OpenSSL3::Timestamp::Response a)
3002
3003			PrintRet TS_RESP_print(Crypt::OpenSSL3::Timestamp::Response a, Crypt::OpenSSL3::BIO bio)
3004
3005			Crypt::OpenSSL3::Timestamp::Response TS_RESP_read_der(class, Crypt::OpenSSL3::BIO bio)
3006			C_ARGS: bio, NULL
3007			POSTCALL:
3008	0	0	if (!RETVAL)
3009	0		XSRETURN_UNDEF;
3010
3011			bool TS_RESP_write_der(Crypt::OpenSSL3::Timestamp::Response x, Crypt::OpenSSL3::BIO bio)
3012			C_ARGS: bio, x
3013
3014			MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::Timestamp::StatusInfo PREFIX = TS_STATUS_INFO_
3015
3016			Crypt::OpenSSL3::Timestamp::StatusInfo TS_STATUS_INFO_new(class)
3017			C_ARGS:
3018
3019			bool TS_STATUS_INFO_set_status(Crypt::OpenSSL3::Timestamp::StatusInfo a, int i)
3020
3021			Crypt::OpenSSL3::ASN1::Integer TS_STATUS_INFO_get_status(Crypt::OpenSSL3::Timestamp::StatusInfo a)
3022
3023			Crypt::OpenSSL3::ASN1::String TS_STATUS_INFO_get_failure_info(Crypt::OpenSSL3::Timestamp::StatusInfo a)
3024
3025
3026			MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::Timestamp::Accuracy PREFIX = TS_ACCURACY_
3027
3028			Crypt::OpenSSL3::Timestamp::Accuracy TS_ACCURACY_new(class)
3029			C_ARGS:
3030
3031			bool TS_ACCURACY_set_seconds(Crypt::OpenSSL3::Timestamp::Accuracy a, Crypt::OpenSSL3::ASN1::Integer seconds)
3032
3033			Crypt::OpenSSL3::ASN1::Integer TS_ACCURACY_get_seconds(Crypt::OpenSSL3::Timestamp::Accuracy a)
3034
3035			bool TS_ACCURACY_set_millis(Crypt::OpenSSL3::Timestamp::Accuracy a, Crypt::OpenSSL3::ASN1::Integer millis)
3036
3037			Crypt::OpenSSL3::ASN1::Integer TS_ACCURACY_get_millis(Crypt::OpenSSL3::Timestamp::Accuracy a)
3038
3039			bool TS_ACCURACY_set_micros(Crypt::OpenSSL3::Timestamp::Accuracy a, Crypt::OpenSSL3::ASN1::Integer micros)
3040
3041			Crypt::OpenSSL3::ASN1::Integer TS_ACCURACY_get_micros(Crypt::OpenSSL3::Timestamp::Accuracy a)
3042
3043
3044			MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::Timestamp::Verifier PREFIX = TS_VERIFY_CTX_
3045
3046			BOOT:
3047			{
3048	60		HV* stash = gv_stashpvs("Crypt::OpenSSL3::Timestamp::Verifier", GV_ADD \| GV_ADDMULTI);
3049	60		CONSTANT2(TS_, VFY_SIGNATURE);
3050	60		CONSTANT2(TS_, VFY_VERSION);
3051	60		CONSTANT2(TS_, VFY_POLICY);
3052	60		CONSTANT2(TS_, VFY_IMPRINT);
3053	60		CONSTANT2(TS_, VFY_DATA);
3054	60		CONSTANT2(TS_, VFY_NONCE);
3055	60		CONSTANT2(TS_, VFY_SIGNER);
3056	60		CONSTANT2(TS_, VFY_TSA_NAME);
3057	60		CONSTANT2(TS_, VFY_ALL_IMPRINT);
3058	60		CONSTANT2(TS_, VFY_ALL_DATA);
3059			}
3060
3061			Crypt::OpenSSL3::Timestamp::Verifier TS_VERIFY_CTX_new()
3062			POSTCALL:
3063	0		TS_VERIFY_CTX_init(RETVAL);
3064
3065			bool TS_VERIFY_CTX_init_from_request(Crypt::OpenSSL3::Timestamp::Verifier ctx, Crypt::OpenSSL3::Timestamp::Request req)
3066
3067			int TS_VERIFY_CTX_set_flags(Crypt::OpenSSL3::Timestamp::Verifier ctx, int f)
3068
3069			int TS_VERIFY_CTX_add_flags(Crypt::OpenSSL3::Timestamp::Verifier ctx, int f)
3070
3071			bool TS_VERIFY_CTX_set_data(Crypt::OpenSSL3::Timestamp::Verifier ctx, Crypt::OpenSSL3::BIO b)
3072			POSTCALL:
3073	0	0	if (RETVAL)
3074	0		BIO_up_ref(b);
3075
3076			bool TS_VERIFY_CTX_set_imprint(Crypt::OpenSSL3::Timestamp::Verifier ctx, unsigned char *hexstr, long length(hexstr))
3077			INIT:
3078	0		hexstr = OPENSSL_strndup(hexstr, XSauto_length_of_hexstr);
3079
3080			bool TS_VERIFY_CTX_set_store(Crypt::OpenSSL3::Timestamp::Verifier ctx, Crypt::OpenSSL3::X509::Store s)
3081			POSTCALL:
3082	0	0	if (RETVAL)
3083	0		X509_STORE_up_ref(s);
3084
3085			bool TS_VERIFY_CTX_set_certs(Crypt::OpenSSL3::Timestamp::Verifier ctx, Crypt::OpenSSL3::X509::Stack certs)
3086			INIT:
3087	0		certs = sk_X509_dup(certs);
3088
3089			bool TS_VERIFY_CTX_verify_response(Crypt::OpenSSL3::Timestamp::Verifier ctx, Crypt::OpenSSL3::Timestamp::Response response)
3090
3091			Bool CLONE_SKIP(...)
3092
3093
3094			MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::NID PREFIX = NID_
3095
3096			Crypt::OpenSSL3::NID NID_create(class, const char oid, const char sn, const char *ln)
3097			C_ARGS: oid, sn, ln
3098			POSTCALL:
3099	0	0	if (RETVAL == NID_undef)
3100	0		XSRETURN_UNDEF;
3101
3102			Crypt::OpenSSL3::NID NID_from_long_name(class, const char* name)
3103			C_ARGS: name
3104
3105			Crypt::OpenSSL3::NID NID_from_short_name(class, const char* name)
3106			C_ARGS: name
3107
3108			Crypt::OpenSSL3::NID NID_from_text(class, const char* name)
3109			C_ARGS: name
3110
3111			const char *NID_get_long_name(Crypt::OpenSSL3::NID n)
3112
3113			const char *NID_get_short_name(Crypt::OpenSSL3::NID n)
3114
3115			Crypt::OpenSSL3::ASN1::Object NID_to_object(Crypt::OpenSSL3::NID n)
3116
3117			bool NID_eq(Crypt::OpenSSL3::NID left, Crypt::OpenSSL3::NID right)
3118
3119			int NID_raw(Crypt::OpenSSL3::NID n)
3120
3121			bool NID_is_undef(Crypt::OpenSSL3::NID n)
3122
3123
3124			MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::Random PREFIX = EVP_RAND_
3125
3126			Crypt::OpenSSL3::Random EVP_RAND_fetch(classname, const char* algorithm, const char* properties = "")
3127			C_ARGS: NULL, algorithm, properties
3128			POSTCALL:
3129	0	0	if (RETVAL == NULL)
3130	0		XSRETURN_UNDEF;
3131
3132			bool EVP_RAND_is_a(Crypt::OpenSSL3::Random rand, const char *name)
3133
3134			const char *EVP_RAND_get_name(Crypt::OpenSSL3::Random rand)
3135
3136			const char *EVP_RAND_get_description(Crypt::OpenSSL3::Random rand)
3137
3138			void EVP_RAND_names_list_all(Crypt::OpenSSL3::Random rand)
3139			PPCODE:
3140	0		PUTBACK;
3141	0		EVP_RAND_names_do_all(rand, EVP_name_callback, iTHX);
3142	0		SPAGAIN;
3143
3144			void EVP_RAND_list_all_provided(classname)
3145			PPCODE:
3146	0		PUTBACK;
3147	0		EVP_RAND_do_all_provided(NULL, EVP_RAND_provided_callback, iTHX);
3148	0		SPAGAIN;
3149
3150			SV* EVP_RAND_get_param(Crypt::OpenSSL3::Random rand, const char* name)
3151			CODE:
3152	0	0	GENERATE_GET_PARAM(EVP_RAND, rand, name)
		0
		0
		0
3153			OUTPUT: RETVAL
3154
3155			MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::Random PREFIX = RAND_
3156
3157			NO_OUTPUT int RAND_bytes(classname, OUTLIST SV* buffer, int num)
3158			INTERFACE: RAND_bytes RAND_priv_bytes
3159			INIT:
3160	0		unsigned char* ptr = make_buffer(&buffer, num);
3161			C_ARGS: ptr, num
3162			POSTCALL:
3163	0	0	if (RETVAL > 0)
3164	0		set_buffer_length(buffer, num);
3165
3166			Crypt::OpenSSL3::Random::Context RAND_get_primary(classname)
3167			INTERFACE: RAND_get_primary RAND_get_public RAND_get_private
3168			C_ARGS: NULL
3169			POSTCALL:
3170			EVP_RAND_CTX_up_ref(RETVAL);
3171
3172			#if OPENSSL_VERSION_PREREQ(3, 2)
3173			Bool RAND_set_public(classname, Crypt::OpenSSL3::Random::Context rand)
3174			INTERFACE: RAND_set_public RAND_set_private
3175			C_ARGS: NULL, rand
3176			POSTCALL:
3177			if (RETVAL)
3178			EVP_RAND_CTX_up_ref(rand);
3179			#endif
3180
3181			MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::Random::Context PREFIX = EVP_RAND_CTX_
3182
3183			Crypt::OpenSSL3::Random::Context EVP_RAND_CTX_new(classname, Crypt::OpenSSL3::Random type, Crypt::OpenSSL3::Random::Context parent = NULL)
3184			C_ARGS: type, parent
3185
3186			Crypt::OpenSSL3::Random EVP_RAND_CTX_get_rand(Crypt::OpenSSL3::Random::Context ctx)
3187			POSTCALL:
3188	0		EVP_RAND_up_ref(RETVAL);
3189
3190			MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::Random::Context PREFIX = EVP_RAND_
3191
3192			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)
3193
3194			bool EVP_RAND_uninstantiate(Crypt::OpenSSL3::Random::Context ctx)
3195
3196			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))
3197			INIT:
3198	0		unsigned char* ptr = make_buffer(&buffer, outlen);
3199			C_ARGS: ctx, ptr, outlen, strength, prediction_resistance, addin, XSauto_length_of_addin
3200			POSTCALL:
3201	0	0	if (RETVAL)
3202	0		set_buffer_length(buffer, outlen);
3203
3204			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)
3205
3206			NO_OUTPUT int EVP_RAND_nonce(Crypt::OpenSSL3::Random::Context ctx, OUTLIST SV* buffer, size_t outlen)
3207			INIT:
3208	0		unsigned char* ptr = make_buffer(&buffer, outlen);
3209			C_ARGS: ctx, ptr, outlen
3210			POSTCALL:
3211	0		set_buffer_length(buffer, RETVAL);
3212
3213			bool EVP_RAND_enable_locking(Crypt::OpenSSL3::Random::Context ctx)
3214
3215			bool EVP_RAND_verify_zeroization(Crypt::OpenSSL3::Random::Context ctx)
3216
3217			unsigned int EVP_RAND_get_strength(Crypt::OpenSSL3::Random::Context ctx)
3218
3219			int EVP_RAND_get_state(Crypt::OpenSSL3::Random::Context ctx)
3220
3221
3222			MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::Cipher PREFIX = EVP_CIPHER_
3223
3224			Crypt::OpenSSL3::Cipher EVP_CIPHER_fetch(classname, const char* algorithm, const char* properties = "")
3225			C_ARGS: NULL, algorithm, properties
3226			POSTCALL:
3227	1	50	if (RETVAL == NULL)
3228	0		XSRETURN_UNDEF;
3229
3230			Crypt::OpenSSL3::NID EVP_CIPHER_get_nid(Crypt::OpenSSL3::Cipher e)
3231
3232			int EVP_CIPHER_get_block_size(Crypt::OpenSSL3::Cipher e)
3233
3234			int EVP_CIPHER_get_key_length(Crypt::OpenSSL3::Cipher e)
3235
3236			int EVP_CIPHER_get_iv_length(Crypt::OpenSSL3::Cipher e)
3237
3238			unsigned long EVP_CIPHER_get_mode(Crypt::OpenSSL3::Cipher e)
3239
3240			int EVP_CIPHER_get_type(Crypt::OpenSSL3::Cipher cipher)
3241
3242			bool EVP_CIPHER_is_a(Crypt::OpenSSL3::Cipher cipher, const char *name)
3243
3244			const char *EVP_CIPHER_get_name(Crypt::OpenSSL3::Cipher cipher)
3245
3246			const char *EVP_CIPHER_get_description(Crypt::OpenSSL3::Cipher cipher)
3247
3248			void EVP_CIPHER_names_list_all(Crypt::OpenSSL3::Cipher cipher)
3249			PPCODE:
3250	0		PUTBACK;
3251	0		EVP_CIPHER_names_do_all(cipher, EVP_name_callback, iTHX);
3252	0		SPAGAIN;
3253
3254			void EVP_CIPHER_list_all_provided(classname)
3255			PPCODE:
3256	1		PUTBACK;
3257	1		EVP_CIPHER_do_all_provided(NULL, EVP_CIPHER_provided_callback, iTHX);
3258	1		SPAGAIN;
3259
3260			SV* EVP_CIPHER_get_param(Crypt::OpenSSL3::Cipher cipher, const char* name)
3261			CODE:
3262	0	0	GENERATE_GET_PARAM(EVP_CIPHER, cipher, name)
		0
		0
		0
3263			OUTPUT: RETVAL
3264
3265
3266			MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::Cipher::Context PREFIX = EVP_CIPHER_CTX_
3267
3268			Crypt::OpenSSL3::Cipher::Context EVP_CIPHER_CTX_new(classname)
3269			C_ARGS:
3270
3271			Crypt::OpenSSL3::Cipher::Context EVP_CIPHER_CTX_dup(Crypt::OpenSSL3::Cipher::Context ctx)
3272
3273			bool EVP_CIPHER_CTX_copy(Crypt::OpenSSL3::Cipher::Context self, Crypt::OpenSSL3::Cipher::Context other)
3274
3275			bool EVP_CIPHER_CTX_reset(Crypt::OpenSSL3::Cipher::Context ctx)
3276
3277			bool EVP_CIPHER_CTX_init(Crypt::OpenSSL3::Cipher::Context ctx, Crypt::OpenSSL3::Cipher type, const unsigned char* key, int length(key), const unsigned char* iv, int length(iv), bool enc, CTX_PARAMS(EVP_CIPHER) params = NULL)
3278			INIT:
3279	2	50	if (XSauto_length_of_key != EVP_CIPHER_get_key_length(type) \|\| XSauto_length_of_iv != EVP_CIPHER_get_iv_length(type))
		50
3280	0		XSRETURN_NO;
3281			C_ARGS: ctx, type, key, iv, enc, params
3282
3283			NO_OUTPUT int EVP_CIPHER_CTX_update(Crypt::OpenSSL3::Cipher::Context ctx, const unsigned char* input, size_t length(input), OUTLIST SV* output)
3284			INIT:
3285	2		int outl = XSauto_length_of_input + EVP_CIPHER_CTX_get_block_size(ctx);
3286	2		unsigned char* ptr = make_buffer(&output, outl);
3287			C_ARGS: ctx, ptr, &outl, input, XSauto_length_of_input
3288			POSTCALL:
3289	2	50	if (RETVAL)
3290	2		set_buffer_length(output, outl);
3291
3292			NO_OUTPUT int EVP_CIPHER_CTX_final(Crypt::OpenSSL3::Cipher::Context ctx, OUTLIST SV* output)
3293			INIT:
3294	2		int size = EVP_CIPHER_CTX_get_block_size(ctx);
3295	2		unsigned char* ptr = make_buffer(&output, size);
3296			C_ARGS: ctx, ptr, &size
3297			POSTCALL:
3298	2	50	if (RETVAL)
3299	2		set_buffer_length(output, size);
3300
3301			bool EVP_CIPHER_CTX_set_params(Crypt::OpenSSL3::Cipher::Context ctx, PARAMS(EVP_CIPHER_CTX) params = NULL)
3302
3303			SV* EVP_CIPHER_CTX_get_param(Crypt::OpenSSL3::Cipher::Context ctx, const char* name)
3304			CODE:
3305	1	50	GENERATE_GET_PARAM(EVP_CIPHER_CTX, ctx, name)
		50
		50
		50
3306			OUTPUT: RETVAL
3307
3308
3309			Crypt::OpenSSL3::NID EVP_CIPHER_CTX_get_nid(Crypt::OpenSSL3::Cipher::Context e)
3310
3311			int EVP_CIPHER_CTX_get_block_size(Crypt::OpenSSL3::Cipher::Context e)
3312
3313			int EVP_CIPHER_CTX_get_key_length(Crypt::OpenSSL3::Cipher::Context e)
3314
3315			int EVP_CIPHER_CTX_get_iv_length(Crypt::OpenSSL3::Cipher::Context e)
3316
3317			unsigned long EVP_CIPHER_CTX_get_mode(Crypt::OpenSSL3::Cipher::Context e)
3318
3319			int EVP_CIPHER_CTX_type(Crypt::OpenSSL3::Cipher::Context ctx)
3320
3321			bool EVP_CIPHER_CTX_set_padding(Crypt::OpenSSL3::Cipher::Context ctx, int padding)
3322
3323			bool EVP_CIPHER_CTX_set_key_length(Crypt::OpenSSL3::Cipher::Context ctx, int keylen)
3324
3325			int EVP_CIPHER_CTX_ctrl(Crypt::OpenSSL3::Cipher::Context ctx, int cmd, int p1, char *p2)
3326
3327			NO_OUTPUT int EVP_CIPHER_CTX_rand_key(Crypt::OpenSSL3::Cipher::Context ctx, OUTLIST SV* key)
3328			INIT:
3329	0		size_t size = EVP_CIPHER_CTX_key_length(ctx);
3330	0		unsigned char* ptr = make_buffer(&key, size);
3331			C_ARGS: ctx, ptr
3332			POSTCALL:
3333	0	0	if (RETVAL > 0)
3334	0		set_buffer_length(key, size);
3335
3336			Crypt::OpenSSL3::Cipher EVP_CIPHER_CTX_get_cipher(Crypt::OpenSSL3::Cipher::Context ctx)
3337
3338			const char *EVP_CIPHER_CTX_get_name(Crypt::OpenSSL3::Cipher::Context ctx)
3339
3340			bool EVP_CIPHER_CTX_is_encrypting(Crypt::OpenSSL3::Cipher::Context ctx)
3341
3342			bool EVP_CIPHER_CTX_set_aead_ivlen(Crypt::OpenSSL3::Cipher::Context ctx, int length)
3343
3344			NO_OUTPUT bool EVP_CIPHER_CTX_get_aead_tag(Crypt::OpenSSL3::Cipher::Context ctx, OUTLIST SV* tag)
3345			INIT:
3346	1		int length = EVP_CIPHER_CTX_get_tag_length(ctx);
3347	1		unsigned char* ptr = make_buffer(&tag, length);
3348			C_ARGS: ctx, ptr, length
3349			POSTCALL:
3350	1	50	if (RETVAL)
3351	1		set_buffer_length(tag, length);
3352
3353			bool EVP_CIPHER_CTX_set_aead_tag(Crypt::OpenSSL3::Cipher::Context ctx, char* ptr, int length(ptr))
3354
3355			#if OPENSSL_VERSION_PREREQ(3, 4)
3356			NO_OUTPUT int EVP_CIPHER_CTX_get_algor(Crypt::OpenSSL3::Cipher::Context ctx, OUTLIST Crypt::OpenSSL3::X509::Algorithm alg)
3357			INIT:
3358			alg = NULL;
3359			POSTCALL:
3360			if (!RETVAL)
3361			XSRETURN_UNDEF;
3362			#endif
3363
3364			MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::MD PREFIX = EVP_MD_
3365
3366			Crypt::OpenSSL3::MD EVP_MD_fetch(classname, const char* algorithm, const char* properties = "")
3367			C_ARGS: NULL, algorithm, properties
3368			POSTCALL:
3369	1	50	if (RETVAL == NULL)
3370	0		XSRETURN_UNDEF;
3371
3372			const char *EVP_MD_get_name(Crypt::OpenSSL3::MD md)
3373
3374			const char *EVP_MD_get_description(Crypt::OpenSSL3::MD md)
3375
3376			bool EVP_MD_is_a(Crypt::OpenSSL3::MD md, const char *name)
3377
3378			void EVP_MD_names_list_all(Crypt::OpenSSL3::MD md)
3379			PPCODE:
3380	0		PUTBACK;
3381	0		EVP_MD_names_do_all(md, EVP_name_callback, iTHX);
3382	0		SPAGAIN;
3383
3384			void EVP_MD_list_all_provided(classname)
3385			PPCODE:
3386	1		PUTBACK;
3387	1		EVP_MD_do_all_provided(NULL, EVP_MD_provided_callback, iTHX);
3388	1		SPAGAIN;
3389
3390			int EVP_MD_get_type(Crypt::OpenSSL3::MD md)
3391
3392			int EVP_MD_get_pkey_type(Crypt::OpenSSL3::MD md)
3393
3394			int EVP_MD_get_size(Crypt::OpenSSL3::MD md)
3395
3396			int EVP_MD_get_block_size(Crypt::OpenSSL3::MD md)
3397
3398			unsigned long EVP_MD_get_flags(Crypt::OpenSSL3::MD md)
3399
3400			#if OPENSSL_VERSION_PREREQ(3, 4)
3401			bool EVP_MD_xof(Crypt::OpenSSL3::MD md)
3402			#endif
3403
3404			SV* EVP_MD_get_param(Crypt::OpenSSL3::MD md, const char* name)
3405			CODE:
3406	0	0	GENERATE_GET_PARAM(EVP_MD, md, name)
		0
		0
		0
3407			OUTPUT: RETVAL
3408
3409			NO_OUTPUT bool EVP_MD_digest(Crypt::OpenSSL3::MD md, const char* input, size_t length(input), OUTLIST SV* digest)
3410			INIT:
3411	0		unsigned int size = EVP_MD_get_size(md);
3412	0		unsigned char* ptr = make_buffer(&digest, size);
3413			C_ARGS: input, XSauto_length_of_input, ptr, &size, md, NULL
3414			POSTCALL:
3415	0	0	if (RETVAL)
3416	0		set_buffer_length(digest, size);
3417
3418
3419			MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::MD::Context PREFIX = EVP_MD_CTX_
3420
3421			Crypt::OpenSSL3::MD::Context EVP_MD_CTX_new(classname)
3422			C_ARGS:
3423
3424			Crypt::OpenSSL3::MD::Context EVP_MD_CTX_dup(Crypt::OpenSSL3::MD::Context ctx)
3425
3426			bool EVP_MD_CTX_copy(Crypt::OpenSSL3::MD::Context self, Crypt::OpenSSL3::MD::Context other)
3427
3428			bool EVP_MD_CTX_reset(Crypt::OpenSSL3::MD::Context ctx)
3429
3430			bool EVP_MD_CTX_init(Crypt::OpenSSL3::MD::Context ctx, Crypt::OpenSSL3::MD type, CTX_PARAMS(EVP_MD) params = NULL)
3431
3432			bool EVP_MD_CTX_update(Crypt::OpenSSL3::MD::Context ctx, const char *d, size_t length(d))
3433
3434			NO_OUTPUT bool EVP_MD_CTX_final(Crypt::OpenSSL3::MD::Context ctx, OUTLIST SV* digest)
3435			INIT:
3436	1		unsigned int size = EVP_MD_CTX_size(ctx);
3437	1		unsigned char* ptr = make_buffer(&digest , size);
3438			C_ARGS: ctx, ptr, &size
3439			POSTCALL:
3440	1	50	if (RETVAL)
3441	1		set_buffer_length(digest, size);
3442
3443			NO_OUTPUT bool EVP_MD_CTX_final_xof(Crypt::OpenSSL3::MD::Context ctx, OUTLIST SV* digest, size_t outlen)
3444			INIT:
3445	0		unsigned char* ptr = make_buffer(&digest, outlen);
3446			C_ARGS: ctx, ptr, outlen
3447			POSTCALL:
3448	0	0	if (RETVAL)
3449	0		set_buffer_length(digest, outlen);
3450
3451			#if OPENSSL_VERSION_PREREQ(3, 3)
3452			NO_OUTPUT bool EVP_MD_CTX_squeeze(Crypt::OpenSSL3::MD::Context ctx, OUTLIST SV* digest, size_t outlen)
3453			INIT:
3454			unsigned char* ptr = make_buffer(&digest, outlen);
3455			C_ARGS: ctx, ptr, outlen
3456			POSTCALL:
3457			if (RETVAL)
3458			set_buffer_length(digest, outlen);
3459			#endif
3460
3461			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)
3462			C_ARGS: ctx, pctx ? &pctx : NULL, type, NULL, pkey
3463
3464			bool EVP_MD_CTX_sign_init_ex(Crypt::OpenSSL3::MD::Context ctx, const char* mdname, Crypt::OpenSSL3::PKey pkey, Crypt::OpenSSL3::PKey::Context pctx = NULL, const char* props = NULL)
3465			C_ARGS: ctx, pctx ? &pctx : NULL, mdname, NULL, props, pkey, NULL
3466
3467			bool EVP_MD_CTX_sign_update(Crypt::OpenSSL3::MD::Context ctx, const char *d, size_t length(d))
3468
3469			SV* EVP_MD_CTX_sign_final(Crypt::OpenSSL3::MD::Context ctx)
3470			CODE:
3471	1		size_t size = 0;
3472	1	50	if (EVP_DigestSignFinal(ctx, NULL, &size) == 1) {
3473	1		unsigned char* ptr = make_buffer(&RETVAL, size);
3474	1	50	if (EVP_DigestSignFinal(ctx, ptr, &size) == 1)
3475	1		set_buffer_length(RETVAL, size);
3476			} else
3477	0		RETVAL = &PL_sv_undef;
3478			OUTPUT: RETVAL
3479
3480			SV* EVP_MD_CTX_sign(Crypt::OpenSSL3::MD::Context ctx, const unsigned char *tbs, size_t length(tbs))
3481			CODE:
3482	0		size_t size = 0;
3483	0	0	if (EVP_DigestSign(ctx, NULL, &size, tbs, XSauto_length_of_tbs) == 1) {
3484	0		unsigned char* ptr = make_buffer(&RETVAL, size);
3485	0	0	if (EVP_DigestSign(ctx, ptr, &size, tbs, XSauto_length_of_tbs) == 1)
3486	0		set_buffer_length(RETVAL, size);
3487			} else
3488	0		RETVAL = &PL_sv_undef;
3489			OUTPUT: RETVAL
3490
3491			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)
3492			C_ARGS: ctx, pctx ? &pctx : NULL, type, NULL, pkey
3493
3494			bool EVP_MD_CTX_verify_update(Crypt::OpenSSL3::MD::Context ctx, const char *d, size_t length(d))
3495
3496			Success EVP_MD_CTX_verify_final(Crypt::OpenSSL3::MD::Context ctx, const unsigned char *sig, size_t length(sig))
3497
3498			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))
3499
3500			bool EVP_MD_CTX_set_params(Crypt::OpenSSL3::MD::Context ctx, PARAMS(EVP_MD_CTX) params = NULL)
3501
3502			SV* EVP_MD_CTX_get_param(Crypt::OpenSSL3::MD::Context ctx, const char* name)
3503			CODE:
3504	0	0	GENERATE_GET_PARAM(EVP_MD_CTX, ctx, name)
		0
		0
		0
3505			OUTPUT: RETVAL
3506
3507
3508			void EVP_MD_CTX_ctrl(Crypt::OpenSSL3::MD::Context ctx, int cmd, int p1, char* p2);
3509
3510			void EVP_MD_CTX_set_flags(Crypt::OpenSSL3::MD::Context ctx, int flags)
3511
3512			void EVP_MD_CTX_clear_flags(Crypt::OpenSSL3::MD::Context ctx, int flags)
3513
3514			int EVP_MD_CTX_test_flags(Crypt::OpenSSL3::MD::Context ctx, int flags)
3515
3516			Crypt::OpenSSL3::MD EVP_MD_CTX_get_md(Crypt::OpenSSL3::MD::Context ctx)
3517
3518			const char *EVP_MD_CTX_get_name(Crypt::OpenSSL3::MD::Context ctx)
3519
3520			int EVP_MD_CTX_get_size(Crypt::OpenSSL3::MD::Context ctx)
3521
3522			int EVP_MD_CTX_get_block_size(Crypt::OpenSSL3::MD::Context ctx)
3523
3524			int EVP_MD_CTX_get_type(Crypt::OpenSSL3::MD::Context ctx)
3525
3526
3527
3528			MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::MAC PREFIX = EVP_MAC_
3529
3530			Crypt::OpenSSL3::MAC EVP_MAC_fetch(classname, const char* algorithm, const char* properties = "")
3531			C_ARGS: NULL, algorithm, properties
3532			POSTCALL:
3533	1	50	if (RETVAL == NULL)
3534	0		XSRETURN_UNDEF;
3535
3536			const char *EVP_MAC_get_name(Crypt::OpenSSL3::MAC mac)
3537
3538			const char *EVP_MAC_get_description(Crypt::OpenSSL3::MAC mac)
3539
3540			bool EVP_MAC_is_a(Crypt::OpenSSL3::MAC mac, const char *name)
3541
3542			void EVP_MAC_names_list_all(Crypt::OpenSSL3::MAC mac)
3543			PPCODE:
3544	0		PUTBACK;
3545	0		EVP_MAC_names_do_all(mac, EVP_name_callback, iTHX);
3546	0		SPAGAIN;
3547
3548			void EVP_MAC_list_all_provided(classname)
3549			PPCODE:
3550	1		PUTBACK;
3551	1		EVP_MAC_do_all_provided(NULL, EVP_MAC_provided_callback, iTHX);
3552	1		SPAGAIN;
3553
3554			SV* EVP_MAC_get_param(Crypt::OpenSSL3::MAC mac, const char* name)
3555			CODE:
3556	0	0	GENERATE_GET_PARAM(EVP_MAC, mac, name)
		0
		0
		0
3557			OUTPUT: RETVAL
3558
3559
3560
3561			MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::MAC::Context PREFIX = EVP_MAC_CTX_
3562
3563			Crypt::OpenSSL3::MAC::Context EVP_MAC_CTX_new(classname, Crypt::OpenSSL3::MAC ctx)
3564			C_ARGS: ctx
3565
3566			Crypt::OpenSSL3::MAC::Context EVP_MAC_CTX_dup(Crypt::OpenSSL3::MAC::Context ctx)
3567
3568			Crypt::OpenSSL3::MAC EVP_MAC_CTX_get_mac(Crypt::OpenSSL3::MAC::Context ctx);
3569			POSTCALL:
3570	0		EVP_MAC_up_ref(RETVAL);
3571
3572			size_t EVP_MAC_CTX_get_mac_size(Crypt::OpenSSL3::MAC::Context ctx)
3573
3574			size_t EVP_MAC_CTX_get_block_size(Crypt::OpenSSL3::MAC::Context ctx)
3575
3576			bool EVP_MAC_CTX_set_params(Crypt::OpenSSL3::MAC::Context ctx, PARAMS(EVP_MAC_CTX) params = NULL)
3577
3578			SV* EVP_MAC_CTX_get_param(Crypt::OpenSSL3::MAC::Context ctx, const char* name)
3579			CODE:
3580	0	0	GENERATE_GET_PARAM(EVP_MAC_CTX, ctx, name)
		0
		0
		0
3581			OUTPUT: RETVAL
3582
3583
3584
3585			MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::MAC::Context PREFIX = EVP_MAC_
3586
3587			bool EVP_MAC_init(Crypt::OpenSSL3::MAC::Context ctx, const unsigned char *key, size_t length(key), PARAMS(EVP_MAC_CTX) params = NULL)
3588
3589			bool EVP_MAC_update(Crypt::OpenSSL3::MAC::Context ctx, const unsigned char *data, size_t length(data))
3590
3591			SV* EVP_MAC_final(Crypt::OpenSSL3::MAC::Context ctx)
3592			CODE:
3593			size_t outsize;
3594	1		EVP_MAC_final(ctx, NULL, &outsize, 0);
3595	1		unsigned char* ptr = make_buffer(&RETVAL, outsize);
3596	1		int result = EVP_MAC_final(ctx, ptr, &outsize, outsize);
3597	1	50	if (result)
3598	1		set_buffer_length(RETVAL, outsize);
3599			OUTPUT: RETVAL
3600
3601			NO_OUTPUT int EVP_MAC_finalXOF(Crypt::OpenSSL3::MAC::Context ctx, OUTLIST SV* code, size_t outsize)
3602			INIT:
3603	0		unsigned char* ptr = make_buffer(&code, outsize);
3604			C_ARGS: ctx, ptr, outsize
3605			POSTCALL:
3606	0	0	if (RETVAL)
3607	0		set_buffer_length(code, outsize);
3608
3609
3610
3611			MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::KDF PREFIX = EVP_KDF_
3612
3613			Crypt::OpenSSL3::KDF EVP_KDF_fetch(classname, const char* algorithm, const char* properties = "")
3614			C_ARGS: NULL, algorithm, properties
3615			POSTCALL:
3616	1	50	if (RETVAL == NULL)
3617	0		XSRETURN_UNDEF;
3618
3619			const char *EVP_KDF_get_name(Crypt::OpenSSL3::KDF kdf)
3620
3621			const char *EVP_KDF_get_description(Crypt::OpenSSL3::KDF kdf)
3622
3623			bool EVP_KDF_is_a(Crypt::OpenSSL3::KDF kdf, const char *name)
3624
3625			void EVP_KDF_names_list_all(Crypt::OpenSSL3::KDF kdf)
3626			PPCODE:
3627	0		PUTBACK;
3628	0		EVP_KDF_names_do_all(kdf, EVP_name_callback, iTHX);
3629	0		SPAGAIN;
3630
3631			void EVP_KDF_list_all_provided(classname)
3632			PPCODE:
3633	1		PUTBACK;
3634	1		EVP_KDF_do_all_provided(NULL, EVP_KDF_provided_callback, iTHX);
3635	1		SPAGAIN;
3636
3637			SV* EVP_KDF_get_param(Crypt::OpenSSL3::KDF kdf, const char* name)
3638			CODE:
3639	0	0	GENERATE_GET_PARAM(EVP_KDF, kdf, name)
		0
		0
		0
3640			OUTPUT: RETVAL
3641
3642
3643			MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::KDF::Context PREFIX = EVP_KDF_CTX_
3644
3645			Crypt::OpenSSL3::KDF::Context EVP_KDF_CTX_new(classname, Crypt::OpenSSL3::KDF ctx)
3646			C_ARGS: ctx
3647
3648			Crypt::OpenSSL3::KDF::Context EVP_KDF_CTX_dup(Crypt::OpenSSL3::KDF::Context ctx)
3649
3650			void EVP_KDF_CTX_reset(Crypt::OpenSSL3::KDF::Context ctx)
3651
3652			size_t EVP_KDF_CTX_get_kdf_size(Crypt::OpenSSL3::KDF::Context ctx)
3653
3654			bool EVP_KDF_CTX_set_params(Crypt::OpenSSL3::KDF::Context ctx, PARAMS(EVP_KDF_CTX) params = NULL)
3655
3656			SV* EVP_KDF_CTX_get_param(Crypt::OpenSSL3::KDF::Context ctx, const char* name)
3657			CODE:
3658	0	0	GENERATE_GET_PARAM(EVP_KDF_CTX, ctx, name)
		0
		0
		0
3659			OUTPUT: RETVAL
3660
3661			Crypt::OpenSSL3::KDF EVP_KDF_CTX_kdf(Crypt::OpenSSL3::KDF::Context ctx)
3662			POSTCALL:
3663	0		EVP_KDF_up_ref(RETVAL);
3664
3665
3666			MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::KDF::Context PREFIX = EVP_KDF_
3667
3668			NO_OUTPUT bool EVP_KDF_derive(Crypt::OpenSSL3::KDF::Context ctx, OUTLIST SV* derived, size_t keylen, PARAMS(EVP_KDF_CTX) params)
3669			INIT:
3670	1		unsigned char* ptr = make_buffer(&derived, keylen);
3671			C_ARGS: ctx, ptr, keylen, params
3672			POSTCALL:
3673	1	50	if (RETVAL)
3674	1		set_buffer_length(derived, keylen);
3675
3676
3677
3678			MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::Signature PREFIX = EVP_SIGNATURE_
3679
3680			Crypt::OpenSSL3::Signature EVP_SIGNATURE_fetch(classname, const char* algorithm, const char* properties = "")
3681			C_ARGS: NULL, algorithm, properties
3682			POSTCALL:
3683	0	0	if (RETVAL == NULL)
3684	0		XSRETURN_UNDEF;
3685
3686			const char *EVP_SIGNATURE_get_name(Crypt::OpenSSL3::Signature signature)
3687
3688			const char *EVP_SIGNATURE_get_description(Crypt::OpenSSL3::Signature signature)
3689
3690			bool EVP_SIGNATURE_is_a(Crypt::OpenSSL3::Signature signature, const char *name)
3691
3692			void EVP_SIGNATURE_names_list_all(Crypt::OpenSSL3::Signature signature)
3693			PPCODE:
3694	0		PUTBACK;
3695	0		EVP_SIGNATURE_names_do_all(signature, EVP_name_callback, iTHX);
3696	0		SPAGAIN;
3697
3698			void EVP_SIGNATURE_list_all_provided(classname)
3699			PPCODE:
3700	0		PUTBACK;
3701	0		EVP_SIGNATURE_do_all_provided(NULL, EVP_SIGNATURE_provided_callback, iTHX);
3702	0		SPAGAIN;
3703
3704
3705			MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::PKey PREFIX = EVP_PKEY_
3706
3707			Crypt::OpenSSL3::PKey EVP_PKEY_new(classname)
3708			C_ARGS:
3709
3710			Crypt::OpenSSL3::PKey EVP_PKEY_new_raw_private_key(classname, const char keytype, const unsigned char key, size_t length(key), const char *propq = "")
3711			C_ARGS: NULL, keytype, propq, key, XSauto_length_of_key
3712			POSTCALL:
3713	0	0	if (RETVAL == NULL)
3714	0		XSRETURN_UNDEF;
3715
3716			Crypt::OpenSSL3::PKey EVP_PKEY_new_raw_public_key(classname, const char keytype, const unsigned char key, size_t length(key), const char *propq = "")
3717			C_ARGS: NULL, keytype, propq, key, XSauto_length_of_key
3718			POSTCALL:
3719	0	0	if (RETVAL == NULL)
3720	0		XSRETURN_UNDEF;
3721
3722			Crypt::OpenSSL3::PKey EVP_PKEY_dup(Crypt::OpenSSL3::PKey ctx)
3723
3724			bool EVP_PKEY_eq(Crypt::OpenSSL3::PKey a, Crypt::OpenSSL3::PKey b)
3725
3726			bool EVP_PKEY_parameters_eq(Crypt::OpenSSL3::PKey a, Crypt::OpenSSL3::PKey b)
3727
3728			NO_OUTPUT void EVP_PKEY_get_raw_private_key(Crypt::OpenSSL3::PKey pkey, OUTLIST SV* key)
3729			CODE:
3730			size_t length;
3731	0		int result = EVP_PKEY_get_raw_private_key(pkey, NULL, &length);
3732	0	0	if (!result)
3733	0		XSRETURN_UNDEF;
3734	0		unsigned char* ptr = make_buffer(&key, length);
3735	0		result = EVP_PKEY_get_raw_private_key(pkey, ptr, &length);
3736	0	0	if (result)
3737	0		set_buffer_length(key, length);
3738
3739
3740			NO_OUTPUT void EVP_PKEY_get_raw_public_key(Crypt::OpenSSL3::PKey pkey, OUTLIST SV* key)
3741			CODE:
3742			size_t length;
3743	0		int result = EVP_PKEY_get_raw_public_key(pkey, NULL, &length);
3744	0	0	if (!result)
3745	0		XSRETURN_UNDEF;
3746	0		unsigned char* ptr = make_buffer(&key, length);
3747	0		result = EVP_PKEY_get_raw_public_key(pkey, ptr, &length);
3748	0	0	if (result)
3749	0		set_buffer_length(key, length);
3750
3751			Crypt::OpenSSL3::PKey EVP_PKEY_read_pem_private_key(Crypt::OpenSSL3::BIO bio, SV* password_cb = undef, const char* propq = "")
3752			C_ARGS: bio, NULL, NULL, NULL, NULL, propq
3753			POSTCALL:
3754	0	0	if (!RETVAL)
3755	0		XSRETURN_UNDEF;
3756
3757			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 = "")
3758			INIT:
3759	0	0	const EVP_CIPHER* cipher = SvOK(cipher_sv) ? get_EVP_CIPHER(aTHX_ cipher_sv) : NULL;
3760	0		STRLEN klen = 0;
3761	0		const unsigned char* kstr = NULL;
3762	0	0	if (SvOK(key))
3763	0		kstr = (unsigned char*)SvPV(key, klen);
3764			C_ARGS: bio, pkey, cipher, kstr, klen, NULL, NULL, NULL, propq
3765
3766			Crypt::OpenSSL3::PKey EVP_PKEY_read_pem_public_key(Crypt::OpenSSL3::BIO bio, const char* propq = "")
3767			C_ARGS: bio, NULL, NULL, NULL, NULL, propq
3768			POSTCALL:
3769	0	0	if (!RETVAL)
3770	0		XSRETURN_UNDEF;
3771
3772			bool EVP_PKEY_write_pem_public_key(Crypt::OpenSSL3::PKey pkey, Crypt::OpenSSL3::BIO bio, const char* propq = "")
3773			C_ARGS: bio, pkey, NULL, propq
3774
3775			Crypt::OpenSSL3::PKey EVP_PKEY_read_der_public_key(Crypt::OpenSSL3::BIO bio, const char* propq = NULL)
3776			C_ARGS: bio, NULL, NULL, propq
3777			POSTCALL:
3778	0	0	if (!RETVAL)
3779	0		XSRETURN_UNDEF;
3780
3781			Crypt::OpenSSL3::PKey EVP_PKEY_read_der_private_key(Crypt::OpenSSL3::BIO bio, const char* propq = NULL)
3782			C_ARGS: bio, NULL, NULL, propq
3783			POSTCALL:
3784	0	0	if (!RETVAL)
3785	0		XSRETURN_UNDEF;
3786
3787			bool EVP_PKEY_write_der_public_key(Crypt::OpenSSL3::PKey a, Crypt::OpenSSL3::BIO bio)
3788			INTERFACE: EVP_PKEY_write_der_public_key EVP_PKEY_write_der_private_key
3789			C_ARGS: bio, a
3790
3791			Crypt::OpenSSL3::NID EVP_PKEY_get_id(Crypt::OpenSSL3::PKey pkey)
3792			POSTCALL:
3793	0	0	if (RETVAL == -1)
3794	0		XSRETURN_UNDEF;
3795
3796			Crypt::OpenSSL3::NID EVP_PKEY_get_base_id(Crypt::OpenSSL3::PKey pkey)
3797
3798			int EVP_PKEY_type(int type)
3799
3800			bool EVP_PKEY_set_type(Crypt::OpenSSL3::PKey pkey, int type)
3801
3802			bool EVP_PKEY_set_type_str(Crypt::OpenSSL3::PKey pkey, const char *str, int length(str))
3803
3804			int EVP_PKEY_get_size(Crypt::OpenSSL3::PKey pkey)
3805
3806			int EVP_PKEY_get_bits(Crypt::OpenSSL3::PKey pkey)
3807
3808			int EVP_PKEY_get_security_bits(Crypt::OpenSSL3::PKey pkey)
3809
3810			bool EVP_PKEY_is_a(Crypt::OpenSSL3::PKey pkey, const char *name)
3811
3812			bool EVP_PKEY_can_sign(Crypt::OpenSSL3::PKey pkey)
3813
3814			void EVP_PKEY_type_names_list_all(Crypt::OpenSSL3::PKey pkey)
3815			PPCODE:
3816	0		PUTBACK;
3817	0		EVP_PKEY_type_names_do_all(pkey, EVP_name_callback, iTHX);
3818	0		SPAGAIN;
3819
3820			const char *EVP_PKEY_get_type_name(Crypt::OpenSSL3::PKey key)
3821
3822			const char *EVP_PKEY_get_description(Crypt::OpenSSL3::PKey key)
3823
3824			Success EVP_PKEY_digestsign_supports_digest(Crypt::OpenSSL3::PKey pkey, const char name, const char propq)
3825			C_ARGS: pkey, NULL, name, propq
3826
3827			NO_OUTPUT int EVP_PKEY_get_default_digest_name(Crypt::OpenSSL3::PKey pkey, OUTLIST SV* mdname)
3828			INIT:
3829	0		char* ptr = (char*)make_buffer(&mdname, 32);
3830			C_ARGS: pkey, ptr, 32
3831			POSTCALL:
3832	0	0	if (RETVAL > 0)
3833	0		set_buffer_length(mdname, strlen(SvPV_nolen(mdname)));
3834
3835			NO_OUTPUT int EVP_PKEY_get_default_digest_nid(Crypt::OpenSSL3::PKey pkey, OUTLIST Crypt::OpenSSL3::NID pnid)
3836			POSTCALL:
3837	0	0	if (RETVAL <= 0)
3838	0		XSRETURN_UNDEF;
3839
3840			int EVP_PKEY_get_field_type(Crypt::OpenSSL3::PKey pkey)
3841
3842			int EVP_PKEY_get_ec_point_conv_form(Crypt::OpenSSL3::PKey pkey)
3843
3844			NO_OUTPUT int EVP_PKEY_get_group_name(Crypt::OpenSSL3::PKey pkey, OUTLIST SV* name, size_t size = 32)
3845			INIT:
3846	0		char* ptr = (char*)make_buffer(&name, size);
3847			C_ARGS: pkey, ptr, size + 1, &size
3848			POSTCALL:
3849	0	0	if (RETVAL)
3850	0		set_buffer_length(name, size);
3851
3852			bool EVP_PKEY_set_encoded_public_key(Crypt::OpenSSL3::PKey pkey, const unsigned char *pub, size_t length(pub))
3853
3854			NO_OUTPUT size_t EVP_PKEY_get_encoded_public_key(Crypt::OpenSSL3::PKey pkey, OUTLIST SV* result)
3855			INIT:
3856	0		unsigned char* ptr = NULL;
3857			C_ARGS: pkey, &ptr
3858			POSTCALL:
3859	0	0	result = RETVAL > 0 ? newSVpvn((char*)ptr, RETVAL) : &PL_sv_undef;
3860	0		OPENSSL_free(ptr);
3861
3862			SV* EVP_PKEY_get_param(Crypt::OpenSSL3::PKey pkey, const char* name)
3863			CODE:
3864	0	0	GENERATE_GET_PARAM(EVP_PKEY, pkey, name)
		0
		0
		0
3865			OUTPUT: RETVAL
3866
3867			bool EVP_PKEY_get_int_param(Crypt::OpenSSL3::PKey pkey, const char *key_name, OUT int out)
3868
3869			bool EVP_PKEY_get_size_t_param(Crypt::OpenSSL3::PKey pkey, const char *key_name, OUT size_t out)
3870
3871			bool EVP_PKEY_get_bn_param(Crypt::OpenSSL3::PKey pkey, const char *key_name, OUT Crypt::OpenSSL3::BigNum bn)
3872
3873			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)
3874
3875			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)
3876
3877			bool EVP_PKEY_set_params(Crypt::OpenSSL3::PKey ctx, PARAMS(EVP_PKEY) params = NULL)
3878
3879			bool EVP_PKEY_set_int_param(Crypt::OpenSSL3::PKey pkey, const char *key_name, int in)
3880
3881			bool EVP_PKEY_set_size_t_param(Crypt::OpenSSL3::PKey pkey, const char *key_name, size_t in)
3882
3883			bool EVP_PKEY_set_bn_param(Crypt::OpenSSL3::PKey pkey, const char *key_name, Crypt::OpenSSL3::BigNum bn)
3884
3885			bool EVP_PKEY_set_utf8_string_param(Crypt::OpenSSL3::PKey pkey, const char key_name, const char str)
3886
3887			bool EVP_PKEY_set_octet_string_param(Crypt::OpenSSL3::PKey pkey, const char key_name, const unsigned char buf, size_t length(buf))
3888
3889			Success EVP_PKEY_print_public(Crypt::OpenSSL3::BIO out, Crypt::OpenSSL3::PKey pkey, int indent)
3890			C_ARGS: out, pkey, indent, NULL
3891
3892			Success EVP_PKEY_print_private(Crypt::OpenSSL3::BIO out, Crypt::OpenSSL3::PKey pkey, int indent)
3893			C_ARGS: out, pkey, indent, NULL
3894
3895			Success EVP_PKEY_print_params(Crypt::OpenSSL3::BIO out, Crypt::OpenSSL3::PKey pkey, int indent)
3896			C_ARGS: out, pkey, indent, NULL
3897
3898			MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::PKey::Context PREFIX = EVP_PKEY_CTX_
3899
3900
3901			Crypt::OpenSSL3::PKey::Context EVP_PKEY_CTX_new(classname, Crypt::OpenSSL3::PKey pkey)
3902			C_ARGS: pkey, NULL
3903
3904			Crypt::OpenSSL3::PKey::Context EVP_PKEY_CTX_new_id(classname, Crypt::OpenSSL3::NID id)
3905			C_ARGS: id, NULL
3906
3907			Crypt::OpenSSL3::PKey::Context EVP_PKEY_CTX_new_from_name(classname, const char name, const char propquery = "")
3908			C_ARGS: NULL, name, propquery
3909
3910			Crypt::OpenSSL3::PKey::Context EVP_PKEY_CTX_new_from_pkey(classname, Crypt::OpenSSL3::PKey pkey, const char *propquery = "")
3911			C_ARGS: NULL, pkey, propquery
3912
3913			Crypt::OpenSSL3::PKey::Context EVP_PKEY_CTX_dup(Crypt::OpenSSL3::PKey::Context ctx)
3914
3915			bool EVP_PKEY_CTX_set_params(Crypt::OpenSSL3::PKey::Context ctx, PARAMS(EVP_PKEY_CTX) params = NULL)
3916
3917			SV* EVP_PKEY_CTX_get_param(Crypt::OpenSSL3::PKey::Context ctx, const char* name)
3918			CODE:
3919	0	0	GENERATE_GET_PARAM(EVP_PKEY_CTX, ctx, name)
		0
		0
		0
3920			OUTPUT: RETVAL
3921
3922			bool EVP_PKEY_CTX_is_a(Crypt::OpenSSL3::PKey::Context ctx, const char *keytype)
3923
3924			#if OPENSSL_VERSION_PREREQ(3, 4)
3925			NO_OUTPUT int EVP_PKEY_CTX_get_algor(Crypt::OpenSSL3::PKey::Context ctx, OUTLIST Crypt::OpenSSL3::X509::Algorithm alg)
3926			INIT:
3927			alg = NULL;
3928			POSTCALL:
3929			if (!RETVAL)
3930			XSRETURN_UNDEF;
3931			#endif
3932
3933			#if OPENSSL_VERSION_PREREQ(3, 4)
3934			bool EVP_PKEY_CTX_set_signature(Crypt::OpenSSL3::PKey::Context pctx, const unsigned char *sig, size_t length(sig))
3935			#endif
3936
3937
3938			MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::PKey::Context PREFIX = EVP_PKEY_
3939
3940			Success EVP_PKEY_keygen_init(Crypt::OpenSSL3::PKey::Context ctx)
3941
3942			Success EVP_PKEY_paramgen_init(Crypt::OpenSSL3::PKey::Context ctx)
3943
3944			NO_OUTPUT int EVP_PKEY_generate(Crypt::OpenSSL3::PKey::Context ctx, OUTLIST Crypt::OpenSSL3::PKey ppkey)
3945			INIT:
3946	2		ppkey = NULL;
3947			POSTCALL:
3948	2	50	if (RETVAL <= 0)
3949	0		XSRETURN_UNDEF;
3950
3951			Success EVP_PKEY_encapsulate_init(Crypt::OpenSSL3::PKey::Context ctx)
3952			C_ARGS: ctx, NULL
3953
3954			void EVP_PKEY_encapsulate(Crypt::OpenSSL3::PKey::Context ctx, OUTLIST SV* wrapped_key, OUTLIST SV* gen_key)
3955			CODE:
3956			size_t wrapped_length, gen_length;
3957	1	50	if (EVP_PKEY_encapsulate(ctx, NULL, &wrapped_length, NULL, &gen_length) != 1)
3958	0		XSRETURN_EMPTY;
3959
3960	1		unsigned char* wrapped_ptr = make_buffer(&wrapped_key, wrapped_length);
3961	1		unsigned char* gen_ptr = make_buffer(&gen_key, gen_length);
3962
3963	1	50	if (EVP_PKEY_encapsulate(ctx, wrapped_ptr, &wrapped_length, gen_ptr, &gen_length)) {
3964	1		set_buffer_length(wrapped_key, wrapped_length);
3965	1		set_buffer_length(gen_key, gen_length);
3966			} else
3967	0		XSRETURN_EMPTY;
3968
3969			Success EVP_PKEY_decapsulate_init(Crypt::OpenSSL3::PKey::Context ctx)
3970			C_ARGS: ctx, NULL
3971
3972			SV* EVP_PKEY_decapsulate(Crypt::OpenSSL3::PKey::Context ctx, const unsigned char *wrapped, size_t length(wrapped))
3973			CODE:
3974			size_t unwrapped_length;
3975	1		int result = EVP_PKEY_decapsulate(ctx, NULL, &unwrapped_length, wrapped, XSauto_length_of_wrapped);
3976	1	50	if (result == 1) {
3977	1		unsigned char* unwrapped_ptr = make_buffer(&RETVAL, unwrapped_length);
3978
3979	1	50	if (EVP_PKEY_decapsulate(ctx, unwrapped_ptr, &unwrapped_length, wrapped, XSauto_length_of_wrapped) == 1)
3980	1		set_buffer_length(RETVAL, unwrapped_length);
3981			} else
3982	0		RETVAL = &PL_sv_undef;
3983			OUTPUT: RETVAL
3984
3985			#if OPENSSL_VERSION_PREREQ(3, 2)
3986			Success EVP_PKEY_auth_encapsulate_init(Crypt::OpenSSL3::PKey::Context ctx, Crypt::OpenSSL3::PKey authpriv)
3987			C_ARGS: ctx, authpriv, NULL
3988
3989			Success EVP_PKEY_auth_decapsulate_init(Crypt::OpenSSL3::PKey::Context ctx, Crypt::OpenSSL3::PKey authpub)
3990			C_ARGS: ctx, authpub, NULL
3991			#endif
3992
3993			Success EVP_PKEY_encrypt_init(Crypt::OpenSSL3::PKey::Context ctx)
3994			C_ARGS: ctx, NULL
3995
3996			SV* EVP_PKEY_encrypt(Crypt::OpenSSL3::PKey::Context ctx, const unsigned char *in, size_t length(in))
3997			CODE:
3998			size_t out_length;
3999	0		bool result = EVP_PKEY_encrypt(ctx, NULL, &out_length, in, XSauto_length_of_in);
4000	0	0	if (result == 1) {
4001	0		unsigned char* out_ptr = make_buffer(&RETVAL, out_length);
4002
4003	0		result = EVP_PKEY_encrypt(ctx, out_ptr, &out_length, in, XSauto_length_of_in);
4004	0	0	if (result == 1)
4005	0		set_buffer_length(RETVAL, out_length);
4006			} else
4007	0		RETVAL = &PL_sv_undef;
4008			OUTPUT: RETVAL
4009
4010			bool EVP_PKEY_decrypt_init(Crypt::OpenSSL3::PKey::Context ctx)
4011			C_ARGS: ctx, NULL
4012
4013			SV* EVP_PKEY_decrypt(Crypt::OpenSSL3::PKey::Context ctx, const unsigned char *in, size_t length(in))
4014			CODE:
4015			size_t out_length;
4016	0	0	if (EVP_PKEY_decrypt(ctx, NULL, &out_length, in, XSauto_length_of_in) == 1) {
4017	0		unsigned char* out_ptr = make_buffer(&RETVAL, out_length);
4018
4019	0	0	if (EVP_PKEY_decrypt(ctx, out_ptr, &out_length, in, XSauto_length_of_in) == 1)
4020	0		set_buffer_length(RETVAL, out_length);
4021			} else
4022	0		RETVAL = &PL_sv_undef;
4023			OUTPUT: RETVAL
4024
4025			bool EVP_PKEY_derive_init(Crypt::OpenSSL3::PKey::Context ctx)
4026			C_ARGS: ctx, NULL
4027
4028			bool EVP_PKEY_derive_set_peer(Crypt::OpenSSL3::PKey::Context ctx, Crypt::OpenSSL3::PKey peer, bool validate_peer = false)
4029
4030			SV* EVP_PKEY_derive(Crypt::OpenSSL3::PKey::Context ctx)
4031			CODE:
4032			size_t key_length;
4033	0	0	if (EVP_PKEY_derive(ctx, NULL, &key_length) == 1) {
4034	0		unsigned char* key_ptr = make_buffer(&RETVAL, key_length);
4035
4036	0	0	if (EVP_PKEY_derive(ctx, key_ptr, &key_length) == 1)
4037	0		set_buffer_length(RETVAL, key_length);
4038			} else
4039	0		RETVAL = &PL_sv_undef;
4040			OUTPUT: RETVAL
4041
4042			Success EVP_PKEY_sign_init(Crypt::OpenSSL3::PKey::Context ctx, Crypt::OpenSSL3::Signature type = NULL, CTX_PARAMS(EVP_SIGNATURE) params = NULL)
4043
4044			SV* EVP_PKEY_sign(Crypt::OpenSSL3::PKey::Context ctx, const unsigned char *tbs, size_t length(tbs))
4045			CODE:
4046			size_t sig_length;
4047	0	0	if (EVP_PKEY_sign(ctx, NULL, &sig_length, tbs, XSauto_length_of_tbs) == 1) {
4048	0		unsigned char* sig_ptr = make_buffer(&RETVAL, sig_length);
4049
4050	0	0	if (EVP_PKEY_sign(ctx, sig_ptr, &sig_length, tbs, XSauto_length_of_tbs) == 1)
4051	0		set_buffer_length(RETVAL, sig_length);
4052			} else
4053	0		RETVAL = &PL_sv_undef;
4054			OUTPUT: RETVAL
4055
4056			Success EVP_PKEY_verify_init(Crypt::OpenSSL3::PKey::Context ctx, Crypt::OpenSSL3::Signature type = NULL, CTX_PARAMS(EVP_SIGNATURE) params = NULL)
4057
4058			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))
4059
4060			#if OPENSSL_VERSION_PREREQ(3, 4)
4061			Success EVP_PKEY_sign_message_init(Crypt::OpenSSL3::PKey::Context ctx, Crypt::OpenSSL3::Signature type = NULL, CTX_PARAMS(EVP_SIGNATURE) params = NULL)
4062
4063			Success EVP_PKEY_sign_message_update(Crypt::OpenSSL3::PKey::Context ctx, unsigned char *in, size_t length(in))
4064
4065			SV* EVP_PKEY_sign_message_final(Crypt::OpenSSL3::PKey::Context ctx)
4066			CODE:
4067			size_t sigsize;
4068			if (EVP_PKEY_sign_message_final(ctx, NULL, &sigsize) == 1) {
4069			unsigned char* ptr = make_buffer(&RETVAL, sigsize);
4070			if (EVP_PKEY_sign_message_final(ctx, ptr, &sigsize) == 1)
4071			set_buffer_length(RETVAL, sigsize);
4072			} else
4073			RETVAL = &PL_sv_undef;
4074			OUTPUT: RETVAL
4075
4076			Success EVP_PKEY_verify_message_init(Crypt::OpenSSL3::PKey::Context ctx, Crypt::OpenSSL3::Signature type = NULL, CTX_PARAMS(EVP_SIGNATURE) params = NULL)
4077
4078			Success EVP_PKEY_verify_message_update(Crypt::OpenSSL3::PKey::Context ctx, unsigned char *in, size_t length(in))
4079
4080			Success EVP_PKEY_verify_message_final(Crypt::OpenSSL3::PKey::Context ctx)
4081
4082			#endif
4083
4084
4085			MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::HPKE PREFIX = OSSL_HPKE_
4086
4087
4088			BOOT:
4089			{
4090			#if OPENSSL_VERSION_PREREQ(3, 2)
4091			HV* stash = gv_stashpvs("Crypt::OpenSSL3::HPKE", GV_ADD \| GV_ADDMULTI);
4092			CONSTANT2(OSSL_HPKE_, KEM_ID_P256);
4093			CONSTANT2(OSSL_HPKE_, KEM_ID_P384);
4094			CONSTANT2(OSSL_HPKE_, KEM_ID_P521);
4095			CONSTANT2(OSSL_HPKE_, KEM_ID_X25519);
4096			CONSTANT2(OSSL_HPKE_, KEM_ID_X448);
4097
4098			CONSTANT2(OSSL_HPKE_, KDF_ID_HKDF_SHA256);
4099			CONSTANT2(OSSL_HPKE_, KDF_ID_HKDF_SHA384);
4100			CONSTANT2(OSSL_HPKE_, KDF_ID_HKDF_SHA512);
4101
4102			CONSTANT2(OSSL_HPKE_, AEAD_ID_AES_GCM_128);
4103			CONSTANT2(OSSL_HPKE_, AEAD_ID_AES_GCM_256);
4104			CONSTANT2(OSSL_HPKE_, AEAD_ID_CHACHA_POLY1305);
4105			CONSTANT2(OSSL_HPKE_, AEAD_ID_EXPORTONLY);
4106
4107			CONSTANT2(OSSL_HPKE_, ROLE_SENDER);
4108			CONSTANT2(OSSL_HPKE_, ROLE_RECEIVER);
4109
4110			CONSTANT2(OSSL_HPKE_, MODE_BASE);
4111			CONSTANT2(OSSL_HPKE_, MODE_PSK);
4112			CONSTANT2(OSSL_HPKE_, MODE_AUTH);
4113			CONSTANT2(OSSL_HPKE_, MODE_PSKAUTH);
4114
4115			CONSTANT2(OSSL_HPKE_, MAX_PARMLEN);
4116			CONSTANT2(OSSL_HPKE_, MIN_PSKLEN);
4117			CONSTANT2(OSSL_HPKE_, MAX_INFOLEN);
4118			#endif
4119			}
4120
4121			#if OPENSSL_VERSION_PREREQ(3, 2)
4122
4123			Crypt::OpenSSL3::HPKE OSSL_HPKE_new(class, unsigned short kem, unsigned short kdf, unsigned short aead)
4124			CODE:
4125			RETVAL = safemalloc(sizeof(OSSL_HPKE_SUITE));
4126			RETVAL->kem_id = kem;
4127			RETVAL->kdf_id = kdf;
4128			RETVAL->aead_id = aead;
4129			OUTPUT: RETVAL
4130
4131			Crypt::OpenSSL3::HPKE OSSL_HPKE_from_string(class, const char *str)
4132			CODE:
4133			RETVAL = safemalloc(sizeof(OSSL_HPKE_SUITE));
4134			if (!OSSL_HPKE_str2suite(str, RETVAL)) {
4135			Safefree(RETVAL);
4136			XSRETURN_UNDEF;
4137			}
4138			OUTPUT: RETVAL
4139
4140			Crypt::OpenSSL3::HPKE OSSL_HPKE_default(class)
4141			CODE:
4142			RETVAL = safemalloc(sizeof(OSSL_HPKE_SUITE));
4143			*RETVAL = (OSSL_HPKE_SUITE)OSSL_HPKE_SUITE_DEFAULT;
4144			OUTPUT: RETVAL
4145
4146			Bool OSSL_HPKE_check(Crypt::OpenSSL3::HPKE suite)
4147			C_ARGS: *suite
4148
4149			size_t OSSL_HPKE_get_ciphertext_size(Crypt::OpenSSL3::HPKE suite, size_t clearlen)
4150			C_ARGS: *suite, clearlen
4151
4152			size_t OSSL_HPKE_get_public_encap_size(Crypt::OpenSSL3::HPKE suite)
4153			C_ARGS: *suite
4154
4155			size_t OSSL_HPKE_get_recommended_ikmelen(Crypt::OpenSSL3::HPKE suite);
4156			C_ARGS: *suite
4157
4158			SV* OSSL_HPKE_keygen(Crypt::OpenSSL3::HPKE suite, OUTLIST Crypt::OpenSSL3::PKey priv, const char *propq = NULL)
4159			CODE:
4160			size_t pub_len = OSSL_HPKE_get_public_encap_size(*suite);
4161			unsigned char* pub = make_buffer(&RETVAL, pub_len);
4162			if (OSSL_HPKE_keygen(*suite, pub, &pub_len, &priv, NULL, 0, NULL, propq))
4163			set_buffer_length(RETVAL, pub_len);
4164			else
4165			XSRETURN_EMPTY;
4166			OUTPUT: RETVAL
4167
4168			SV* OSSL_HPKE_suite(Crypt::OpenSSL3::HPKE suite)
4169			CODE:
4170			RETVAL = newSVpvn((const char)suite, sizeof suite);
4171			OUTPUT: RETVAL
4172
4173			unsigned short OSSL_HPKE_kem_id(Crypt::OpenSSL3::HPKE suite)
4174
4175			unsigned short OSSL_HPKE_kdf_id(Crypt::OpenSSL3::HPKE suite)
4176
4177			unsigned short OSSL_HPKE_aead_id(Crypt::OpenSSL3::HPKE suite)
4178
4179			void OSSL_HPKE_get_grease_value(Crypt::OpenSSL3::HPKE suite, OUTLIST SV* enc, OUTLIST SV* ct, size_t pt_length, const char *propq = NULL)
4180			CODE:
4181			size_t enc_length = OSSL_HPKE_get_public_encap_size(*suite);
4182			unsigned char* enc_ptr = make_buffer(&enc, enc_length);
4183			size_t ct_length = OSSL_HPKE_get_ciphertext_size(*suite, pt_length);
4184			unsigned char* ct_ptr = make_buffer(&ct, ct_length);
4185			int retval = OSSL_HPKE_get_grease_value(suite, suite, enc_ptr, &enc_length, ct_ptr, ct_length, NULL, propq);
4186			if (retval) {
4187			set_buffer_length(enc, enc_length);
4188			set_buffer_length(ct, ct_length);
4189			}
4190			else
4191			XSRETURN_EMPTY;
4192
4193			#endif
4194
4195
4196			MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::HPKE::Context PREFIX = OSSL_HPKE_
4197
4198			#if OPENSSL_VERSION_PREREQ(3, 2)
4199
4200			SV* OSSL_HPKE_encapsulate(Crypt::OpenSSL3::HPKE::Context hpke, const unsigned char pub, size_t length(pub), const unsigned char info, size_t length(info))
4201			CODE:
4202			size_t enc_length = OSSL_HPKE_get_public_encap_size(hpke->suite);
4203			unsigned char* enc_ptr = make_buffer(&RETVAL, enc_length);
4204			if (OSSL_HPKE_encap(hpke->context, enc_ptr, &enc_length, pub, XSauto_length_of_pub, info, XSauto_length_of_info))
4205			set_buffer_length(RETVAL, enc_length);
4206			OUTPUT: RETVAL
4207
4208			SV* OSSL_HPKE_seal(Crypt::OpenSSL3::HPKE::Context hpke, const unsigned char pt, size_t length(pt), const unsigned char aad, size_t length(aad))
4209			CODE:
4210			size_t enc_length = OSSL_HPKE_get_ciphertext_size(hpke->suite, XSauto_length_of_pt);
4211			unsigned char* enc_ptr = make_buffer(&RETVAL, enc_length);
4212			if (OSSL_HPKE_seal(hpke->context, enc_ptr, &enc_length, aad, XSauto_length_of_aad, pt, XSauto_length_of_pt))
4213			set_buffer_length(RETVAL, enc_length);
4214			OUTPUT: RETVAL
4215
4216			Bool OSSL_HPKE_decapsulate(Crypt::OpenSSL3::HPKE::Context hpke, const unsigned char enc, size_t length(enc), Crypt::OpenSSL3::PKey recippriv, const unsigned char info, size_t length(info))
4217			C_ARGS: hpke->context, enc, XSauto_length_of_enc, recippriv, info, XSauto_length_of_info
4218
4219			SV* OSSL_HPKE_open(Crypt::OpenSSL3::HPKE::Context hpke, const unsigned char ct, size_t length(ct), const unsigned char aad, size_t length(aad))
4220			CODE:
4221			size_t pt_length = XSauto_length_of_ct;
4222			unsigned char* pt_ptr = make_buffer(&RETVAL, pt_length);
4223			if (OSSL_HPKE_open(hpke->context, pt_ptr, &pt_length, aad, XSauto_length_of_aad, ct, XSauto_length_of_ct))
4224			set_buffer_length(RETVAL, pt_length);
4225			OUTPUT: RETVAL
4226
4227			SV* OSSL_HPKE_export(Crypt::OpenSSL3::HPKE::Context hpke, size_t secret_length, const unsigned char *label, size_t length(label))
4228			CODE:
4229			unsigned char* secret = make_buffer(&RETVAL, secret_length);
4230			if (OSSL_HPKE_export(hpke->context, secret, secret_length, label, XSauto_length_of_label))
4231			set_buffer_length(RETVAL, secret_length);
4232			OUTPUT: RETVAL
4233
4234			#endif
4235
4236
4237			MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::HPKE::Context PREFIX = OSSL_HPKE_CTX_
4238
4239			#if OPENSSL_VERSION_PREREQ(3, 2)
4240
4241			Crypt::OpenSSL3::HPKE::Context OSSL_HPKE_CTX_new(class, Crypt::OpenSSL3::HPKE suite, int role, int mode = OSSL_HPKE_MODE_BASE, const char *propq = NULL)
4242			CODE:
4243			OSSL_HPKE_CTX* ctx = OSSL_HPKE_CTX_new(mode, *suite, role, NULL, propq);
4244			if (!ctx)
4245			XSRETURN_UNDEF;
4246			RETVAL = safemalloc(sizeof(HPKE));
4247			RETVAL->suite = *suite;
4248			RETVAL->context = ctx;
4249			OUTPUT: RETVAL
4250
4251			bool OSSL_HPKE_CTX_set_authpriv(Crypt::OpenSSL3::HPKE::Context hpke, Crypt::OpenSSL3::PKey priv)
4252			C_ARGS: hpke->context, priv
4253
4254			bool OSSL_HPKE_CTX_set_authpub(Crypt::OpenSSL3::HPKE::Context hpke, unsigned char *input, size_t length(input))
4255			INTERFACE: OSSL_HPKE_CTX_set_authpub OSSL_HPKE_CTX_set_ikme
4256			C_ARGS: hpke->context, input, XSauto_length_of_input
4257
4258			bool OSSL_HPKE_CTX_set_psk(Crypt::OpenSSL3::HPKE::Context hpke, const char pskid, const unsigned char psk, size_t length(psk))
4259			C_ARGS: hpke->context, pskid, psk, XSauto_length_of_psk
4260
4261			NO_OUTPUT int OSSL_HPKE_CTX_get_seq(Crypt::OpenSSL3::HPKE::Context hpke, OUTLIST uint64_t seq)
4262			C_ARGS: hpke->context, &seq
4263			POSTCALL:
4264			if (!RETVAL)
4265			XSRETURN_UNDEF;
4266
4267			bool OSSL_HPKE_CTX_set_seq(Crypt::OpenSSL3::HPKE::Context hpke, uint64_t seq)
4268			C_ARGS: hpke->context, seq
4269
4270			Bool CLONE_SKIP(...)
4271
4272			#endif