File Coverage

lib/Crypt/OpenSSL3.xs
Criterion Covered Total %
statement 313 1269 24.6
branch 58 710 8.1
condition n/a
subroutine n/a
pod n/a
total 371 1979 18.7


line stmt bran cond sub pod time 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             #include "ppport.h"
12              
13             #include
14             #include
15             #include
16             #include
17             #include
18             #include
19             #include
20             #include
21             #if OPENSSL_VERSION_PREREQ(3, 2)
22             #include
23             #endif
24              
25 12           static unsigned char* S_make_buffer(pTHX_ SV** retval, size_t size) {
26 12           *retval = newSVpv("", 0);
27 12 50         char* ptr = SvGROW(*retval, size);
    100          
28 12           return (unsigned char*)ptr;
29             }
30             #define make_buffer(svp, size) S_make_buffer(aTHX_ svp, size)
31              
32 1           static char* S_grow_buffer(pTHX_ SV* buffer, size_t size) {
33 1 50         SvUPGRADE(buffer, SVt_PV);
34 1 50         SV_CHECK_THINKFIRST(buffer);
35 1 50         return SvGROW(buffer, size);
    50          
36             }
37             #define grow_buffer(sv, size) S_grow_buffer(aTHX_ sv, size)
38              
39 13           static inline void S_set_buffer_length(pTHX_ SV* buffer, ssize_t result) {
40 13           SvCUR_set(buffer, result);
41 13           SvPOK_only(buffer);
42 13           }
43             #define set_buffer_length(buffer, result) S_set_buffer_length(aTHX_ buffer, result)
44              
45             #define TYPE_TYPE(c_type, xs_type) typedef c_type * Crypt__OpenSSL3__ ## xs_type;
46             #define MAGIC_TABLE(xs_type, dup, free)\
47             static const MGVTBL Crypt__OpenSSL3__ ## xs_type ## _magic = {\
48             .svt_free = free,\
49             .svt_dup = dup,\
50             };
51              
52             #define TYPE_COMMON(c_type, xs_type, p_type)\
53             static inline SV* make_ ## c_type(pTHX_ c_type* var) {\
54             SV* result = newSV(0);\
55             const char* classname = "Crypt::OpenSSL3::" #p_type;\
56             const MGVTBL* mgvtbl = &Crypt__OpenSSL3__## xs_type ##_magic;\
57             MAGIC* magic = sv_magicext(newSVrv(result, classname), NULL, PERL_MAGIC_ext, mgvtbl, (const char*)var, 0);\
58             magic->mg_flags |= MGf_DUP;\
59             return result;\
60             }\
61             static inline c_type* get_ ## c_type (pTHX_ SV* value) {\
62             if (!SvROK(value))\
63             return NULL;\
64             MAGIC* magic = mg_findext(SvRV(value), PERL_MAGIC_ext, &Crypt__OpenSSL3__## xs_type ##_magic);\
65             return magic ? (c_type*)magic->mg_ptr : NULL;\
66             }
67              
68             #define DUPLICATING_TYPE(c_type, xs_type, p_type)\
69             TYPE_TYPE(c_type, xs_type)\
70             static int c_type ## _magic_dup(pTHX_ MAGIC* mg, CLONE_PARAMS* params) {\
71             PERL_UNUSED_VAR(params);\
72             mg->mg_ptr = (char*)c_type ## _dup((c_type*)mg->mg_ptr);\
73             return 0;\
74             }\
75             static int c_type ## _magic_free(pTHX_ SV* sv, MAGIC* mg) {\
76             PERL_UNUSED_VAR(sv);\
77             c_type ## _free((c_type*)mg->mg_ptr);\
78             return 0;\
79             }\
80             MAGIC_TABLE(xs_type, c_type ## _magic_dup, c_type ## _magic_free)\
81             TYPE_COMMON(c_type, xs_type, p_type)
82              
83             #define COUNTING_TYPE(c_type, xs_type, p_type)\
84             typedef c_type * Crypt__OpenSSL3__ ## xs_type;\
85             static int c_type ## _magic_dup(pTHX_ MAGIC* mg, CLONE_PARAMS* params) {\
86             PERL_UNUSED_VAR(params);\
87             c_type ## _up_ref((c_type*)mg->mg_ptr);\
88             return 0;\
89             }\
90             static int c_type ## _magic_free(pTHX_ SV* sv, MAGIC* mg) {\
91             PERL_UNUSED_VAR(sv);\
92             c_type ## _free((c_type*)mg->mg_ptr);\
93             return 0;\
94             }\
95             MAGIC_TABLE(xs_type, c_type ## _magic_dup, c_type ## _magic_free)\
96             TYPE_COMMON(c_type, xs_type, p_type)
97              
98             #define SIMPLE_TYPE(c_type, xs_type, p_type, modifier)\
99             TYPE_TYPE(modifier c_type, xs_type)\
100             MAGIC_TABLE(xs_type, NULL, NULL)\
101             TYPE_COMMON(c_type, xs_type, p_type)
102              
103             #if !OPENSSL_VERSION_PREREQ(3, 2)
104 0           static EVP_MD_CTX *EVP_MD_CTX_dup(const EVP_MD_CTX *in) {
105 0           EVP_MD_CTX* result = EVP_MD_CTX_new();
106 0           EVP_MD_CTX_copy(result, in);
107 0           return result;
108             }
109              
110 0           static EVP_CIPHER_CTX *EVP_CIPHER_CTX_dup(const EVP_CIPHER_CTX *in) {
111 0           EVP_CIPHER_CTX* result = EVP_CIPHER_CTX_new();
112 0           EVP_CIPHER_CTX_copy(result, in);
113 0           return result;
114             }
115             #define EVP_RAND_CTX_up_ref(ctx) NULL
116             #endif
117              
118             typedef unsigned long Crypt__OpenSSL3__Error;
119 0           COUNTING_TYPE(EVP_RAND, Random, Random)
  0            
  0            
  0            
120 0           COUNTING_TYPE(EVP_RAND_CTX, Random__Context, Random::Context)
  0            
  0            
121 249 0         COUNTING_TYPE(EVP_CIPHER, Cipher, Cipher)
  0 0          
  124            
  125            
  0            
122 2           DUPLICATING_TYPE(EVP_CIPHER_CTX, Cipher__Context, Cipher::Context)
  2            
  0            
123 45           COUNTING_TYPE(EVP_MD, MD, MD)
  22            
  23            
  0            
124 3           DUPLICATING_TYPE(EVP_MD_CTX, MD__Context, MD::Context)
  3            
  0            
125 19           COUNTING_TYPE(EVP_MAC, MAC, MAC)
  9            
  10            
  0            
126 1           DUPLICATING_TYPE(EVP_MAC_CTX, MAC__Context, MAC::Context)
  1            
  0            
127 25           COUNTING_TYPE(EVP_KDF, KDF, KDF)
  12            
  13            
  0            
128 1           DUPLICATING_TYPE(EVP_KDF_CTX, KDF__Context, KDF::Context)
  1            
  0            
129 0           COUNTING_TYPE(EVP_SIGNATURE, Signature, Signature)
  0            
  0            
  0            
130 2           DUPLICATING_TYPE(EVP_PKEY, PKey, PKey)
  2            
  0            
131 4           DUPLICATING_TYPE(EVP_PKEY_CTX, PKey__Context, PKey::Context)
  4            
  0            
132              
133             typedef BIGNUM BN;
134 6 50         DUPLICATING_TYPE(BN, BigNum, BigNum);
  6 0          
  0            
  0            
  0            
135             #define BN_CTX_dup(old) BN_CTX_new()
136 0           DUPLICATING_TYPE(BN_CTX, BigNum__Context, BigNum::Context)
  0            
  0            
137              
138 0           ASN1_TYPE* ASN1_TYPE_dup(ASN1_TYPE* a) {
139 0 0         if (!a)
140 0           return NULL;
141              
142 0           int type = ASN1_TYPE_get(a);
143 0           ASN1_TYPE* result = ASN1_TYPE_new();
144             void* value;
145 0 0         if (type == V_ASN1_NULL || type == V_ASN1_BOOLEAN)
    0          
146 0           ASN1_TYPE_set(result, type, a->value.ptr);
147 0 0         else if (type == V_ASN1_OBJECT)
148 0           ASN1_TYPE_set(result, type, OBJ_dup(a->value.object));
149             else
150 0           ASN1_TYPE_set(result, type, ASN1_STRING_dup(a->value.ia5string));
151              
152 0           return result;
153             }
154 0           DUPLICATING_TYPE(ASN1_TYPE, ASN1__Value, ASN1::Value)
  0            
  0            
  0            
155             typedef int Crypt__OpenSSL3__NID;
156             #define ASN1_OBJECT_dup OBJ_dup
157 0 0         DUPLICATING_TYPE(ASN1_OBJECT, ASN1__Object, ASN1::Object)
  0 0          
  0            
  0            
  0            
158              
159             typedef struct {
160             const unsigned char* ptr;
161             const unsigned char* begin;
162             const unsigned char* end;
163             } ASN1_DECODER, *Crypt__OpenSSL3__ASN1__Decoder;
164              
165 0           static int ASN1_DECODER_dup(pTHX_ MAGIC* mg, CLONE_PARAMS* params) {
166 0           ASN1_DECODER* buffer = (ASN1_DECODER*)mg->mg_ptr;
167 0           STRLEN used = buffer->ptr - buffer->begin;
168             STRLEN len;
169 0           buffer->begin = SvPVbyte(mg->mg_obj, len);
170 0           buffer->ptr = buffer->begin + used;
171 0           return 0;
172             }
173              
174             static const MGVTBL Crypt__OpenSSL3__ASN1__Decoder_magic = {
175             .svt_dup = ASN1_DECODER_dup,
176             };
177              
178 0 0         DUPLICATING_TYPE(X509, X509, X509)
  0 0          
  0            
  0            
  0            
179 0           COUNTING_TYPE(X509_STORE, X509__Store, X509::Store)
  0            
  0            
180 0           DUPLICATING_TYPE(X509_NAME, X509__Name, X509::Name)
  0            
  0            
  0            
181 0           DUPLICATING_TYPE(X509_NAME_ENTRY, X509__Name__Entry, X509::Name::Entry)
  0            
  0            
182 0           DUPLICATING_TYPE(X509_REQ, X509__Request, X509::Request)
  0            
  0            
183 0           DUPLICATING_TYPE(X509_ALGOR, X509__Algorithm, X509::Algorithm)
  0            
  0            
184 0 0         DUPLICATING_TYPE(X509_EXTENSION, X509__Extension, X509::Extension)
  0 0          
  0            
  0            
  0            
185 0           DUPLICATING_TYPE(X509_ATTRIBUTE, X509__Attribute, X509::Attribute)
  0            
  0            
186             SIMPLE_TYPE(X509_VERIFY_PARAM, X509__VerifyParam, X509::VerifyParam, )
187             #define X509_STORE_CTX_dup(ctx) NULL
188 0           DUPLICATING_TYPE(X509_STORE_CTX, X509__Store__Context, X509::Store::Context)
  0            
  0            
189 0           EDIPARTYNAME* EDIPARTYNAME_dup(EDIPARTYNAME* orig) {
190 0           EDIPARTYNAME* result = EDIPARTYNAME_new();
191 0           result->nameAssigner = ASN1_STRING_dup(orig->nameAssigner);
192 0           result->partyName = ASN1_STRING_dup(orig->partyName);
193 0           }
194 0           DUPLICATING_TYPE(EDIPARTYNAME, X509__EDIPartyName, X509::EDIPartyName)
  0            
  0            
  0            
195 0           DUPLICATING_TYPE(GENERAL_NAME, X509__GeneralName, X509::GeneralName)
  0            
  0            
  0            
196             typedef long Crypt__OpenSSL3__X509__VerifyResult;
197             #define CTLOG_STORE_dup(s) NULL
198 0           DUPLICATING_TYPE(CTLOG_STORE, X509__Transparency__Log__Store, X509::Transparency::Log::Store)
  0            
  0            
199             #define CT_POLICY_EVAL_CTX_dup(s) NULL
200 0           DUPLICATING_TYPE(CT_POLICY_EVAL_CTX, X509__Transparency__Evaluator, X509::Transparency::Evaluator)
  0            
  0            
201 0           static SCT* SCT_dup(const SCT* input) {
202 0           unsigned char* serialized = NULL;
203 0           int size = i2o_SCT(input, &serialized);
204 0 0         if (size < 0)
205 0           return NULL;
206 0           const unsigned char* ptr = serialized;
207 0           SCT* output = o2i_SCT(NULL, &ptr, size);
208 0           OPENSSL_free(serialized);
209 0           return output;
210             }
211 0           DUPLICATING_TYPE(SCT, X509__Transparency__Timestamp, X509::Transparency::Timestamp)
  0            
  0            
  0            
212 0           DUPLICATING_TYPE(PKCS7, PKCS7, PKCS7)
  0            
  0            
213              
214 0           DUPLICATING_TYPE(TS_REQ, Timestamp__Request, Timestamp::Request)
  0            
  0            
215 0           DUPLICATING_TYPE(TS_RESP, Timestamp__Response, Timestamp::Response)
  0            
  0            
216 0           DUPLICATING_TYPE(TS_MSG_IMPRINT, Timestamp__Imprint, Timestamp::Imprint)
  0            
  0            
217 0           DUPLICATING_TYPE(TS_TST_INFO, Timestamp__TokenInfo, Timestamp::TokenInfo)
  0            
  0            
218 0           DUPLICATING_TYPE(TS_STATUS_INFO, Timestamp__StatusInfo, Timestamp::StatusInfo)
  0            
  0            
219 0           DUPLICATING_TYPE(TS_ACCURACY, Timestamp__Accuracy, Timestamp::Accuracy)
  0            
  0            
220             #define TS_RESP_CTX_dup(ctx) NULL
221 0           DUPLICATING_TYPE(TS_RESP_CTX, Timestamp__Responder, Timestamp::Responder)
  0            
  0            
222             #define TS_VERIFY_CTX_dup(ctx) NULL
223 0           DUPLICATING_TYPE(TS_VERIFY_CTX, Timestamp__Verifier, Timestamp::Verifier)
  0            
  0            
224              
225 2           COUNTING_TYPE(BIO, BIO, BIO)
  2            
  0            
226             #if OPENSSL_VERSION_PREREQ(3, 2)
227             DUPLICATING_TYPE(BIO_ADDR, BIO__Address, BIO::Address)
228             typedef BIO_POLL_DESCRIPTOR* Crypt__OpenSSL3__BIO__PollDescriptor;
229             #endif
230              
231             SIMPLE_TYPE(SSL_METHOD, SSL__Method, SSL::Method, const)
232 1           COUNTING_TYPE(SSL_CTX, SSL__Context, SSL::Context)
  1            
  0            
233 2           COUNTING_TYPE(SSL, SSL, SSL)
  2            
  0            
234 0           DUPLICATING_TYPE(SSL_SESSION, SSL__Session, SSL::Session)
  0            
  0            
235             SIMPLE_TYPE(SSL_CIPHER, SSL__Cipher, SSL::Cipher, const)
236              
237             #if OPENSSL_VERSION_PREREQ(3, 2)
238             typedef struct HPKE {
239             OSSL_HPKE_CTX* context;
240             OSSL_HPKE_SUITE suite;
241             } HPKE;
242              
243             #define HPKE_dup(hpke) NULL
244              
245             static void HPKE_free(HPKE* hpke) {
246             OSSL_HPKE_CTX_free(hpke->context);
247             Safefree(hpke);
248             }
249              
250             DUPLICATING_TYPE(HPKE, HPKE__Context, HPKE::Context)
251             typedef OSSL_HPKE_SUITE* Crypt__OpenSSL3__HPKE;
252             #endif
253              
254             #define PARAMS(a) OSSL_PARAM*
255             #define CTX_PARAMS(a) OSSL_PARAM*
256              
257             #undef OPENSSL_VERSION_TEXT
258             #define OPENSSL_VERSION_TEXT OPENSSL_VERSION
259              
260             #define BIO_new_mem() BIO_new(BIO_s_mem())
261             #define BIO_POLL_DESCRIPTOR_new(class) safecalloc(1, sizeof(BIO_POLL_DESCRIPTOR))
262             #define BIO_POLL_DESCRIPTOR_type(desc) ((desc)->type)
263             #define BIO_POLL_DESCRIPTOR_fd(desc) ((desc)->value.fd)
264             #define PEM_write PEM_write_bio
265             #define PEM_read PEM_read_bio
266              
267             #define BN_generate_prime BN_generate_prime_ex2
268              
269             #define OBJ_get_data OBJ_get0_data
270             #define OBJ_from_nid OBJ_nid2obj
271             #define OBJ_from_text OBJ_txt2obj
272             #define OBJ_to_nid OBJ_obj2nid
273 0           SV* S_OBJ_to_text(pTHX_ const ASN1_OBJECT* object, bool no_name) {
274 0           SV* result = &PL_sv_undef;
275 0           int buf_len = OBJ_obj2txt(NULL, 0, object, no_name);
276 0 0         if (buf_len > 0) {
277 0           unsigned char* ptr = make_buffer(&result, buf_len + 1);
278 0 0         if (OBJ_obj2txt((char*)ptr, buf_len + 1, object, no_name) > 0)
279 0           set_buffer_length(result, buf_len);
280             }
281 0           return result;
282             }
283             #define OBJ_to_text(object, no_name) S_OBJ_to_text(aTHX_ object, no_name)
284              
285 0           SV* S_ASN1_DECODER_new(pTHX_ SV* input) {
286 0           SV* buffer = newSVsv(input);
287             ASN1_DECODER tmp;
288             STRLEN len;
289 0           tmp.begin = tmp.ptr = SvPVbyte(buffer, len);
290 0           tmp.end = tmp.begin + len;
291 0           SV* result = newSV(0);
292 0           MAGIC* mg = sv_magicext(newSVrv(result, "Crypt::OpenSSL3::ASN1::Decoder"), buffer, PERL_MAGIC_ext, &Crypt__OpenSSL3__ASN1__Decoder_magic, (const char*)&tmp, sizeof(ASN1_DECODER));
293 0           mg->mg_flags |= MGf_DUP;
294 0           return result;
295             }
296             #define ASN1_DECODER_new(input) S_ASN1_DECODER_new(aTHX_ input)
297             #define ASN1_DECODER_get_bytes_left(buffer) (buffer->end - buffer->ptr)
298              
299 0           SV* S_ASN1_STRING_to_SV(pTHX_ int type, const ASN1_STRING* x) {
300 0           const unsigned char* data = ASN1_STRING_get0_data(x);
301 0           int length = ASN1_STRING_length(x);
302 0 0         int flags = type == V_ASN1_UTF8STRING ? SVf_UTF8 : 0;
303 0           return newSVpvn_flags((const char*)data, length, flags);
304             }
305             #define ASN1_STRING_to_SV(type, x) S_ASN1_STRING_to_SV(aTHX_ type, x)
306             #define ASN1_STRING_get_data(x) ASN1_STRING_to_SV(ASN1_STRING_type(x), x)
307 0           ASN1_STRING* S_ASN1_STRING_from_SV(pTHX_ int type, SV* value) {
308             STRLEN length;
309 0           bool utf8 = type == V_ASN1_UTF8STRING;
310 0 0         const char* ptr = utf8 ? SvPVutf8(value, length) : SvPVbyte(value, length);
311 0           ASN1_STRING* result = ASN1_STRING_type_new(type);
312 0           ASN1_STRING_set(result, ptr, length);
313 0           return result;
314             }
315             #define ASN1_STRING_from_SV(type, value) S_ASN1_STRING_from_SV(aTHX_ type, value)
316              
317 0           SV* S_ASN1_INTEGER_to_SV(pTHX_ const ASN1_INTEGER* x) {
318 0           BN* bn = ASN1_INTEGER_to_BN(x, NULL);
319 0           return make_BN(aTHX_ bn);
320             }
321             #define ASN1_INTEGER_to_SV(x) S_ASN1_INTEGER_to_SV(aTHX_ x)
322 0           ASN1_INTEGER* S_ASN1_INTEGER_from_SV(pTHX_ SV* value) {
323             const BIGNUM* bn;
324 0 0         if ((bn = get_BN(aTHX_ value))) {
325 0           return BN_to_ASN1_INTEGER(bn, NULL);
326             } else {
327 0           ASN1_INTEGER* result = ASN1_INTEGER_new();
328 0           ASN1_INTEGER_set_int64(result, SvIV(value));
329 0           return result;
330             }
331             }
332             #define ASN1_INTEGER_from_SV(value) S_ASN1_INTEGER_from_SV(aTHX_ value)
333              
334             #define ASN1_TYPE_get_type ASN1_TYPE_get
335 0           SV* S_ASN1_TYPE_get_value(pTHX_ ASN1_TYPE* a) {
336 0           int type = ASN1_TYPE_get(a);
337 0 0         if (type == V_ASN1_NULL)
338 0           return &PL_sv_undef;
339 0 0         else if (type == V_ASN1_BOOLEAN)
340 0 0         return boolSV(a->value.boolean);
341 0 0         else if (type == V_ASN1_OBJECT)
342 0           return make_ASN1_OBJECT(aTHX_ ASN1_OBJECT_dup(a->value.object));
343 0 0         else if (type == V_ASN1_INTEGER || type == V_ASN1_ENUMERATED)
    0          
344 0           return ASN1_INTEGER_to_SV(a->value.integer);
345 0 0         else if (type == V_ASN1_SEQUENCE || type == V_ASN1_SET) {
    0          
346 0           SV* internal = ASN1_STRING_to_SV(type, a->value.asn1_string);
347 0           SV* result = ASN1_DECODER_new(internal);
348 0           SvREFCNT_dec(internal);
349 0           return result;
350             } else
351 0           return ASN1_STRING_to_SV(type, a->value.asn1_string);
352             }
353             #define ASN1_TYPE_get_value(a) S_ASN1_TYPE_get_value(aTHX_ a)
354              
355             #define X509_read_der d2i_X509_bio
356             #define X509_write_der i2d_X509_bio
357             #define X509_read_pem PEM_read_bio_X509
358             #define X509_write_pem PEM_write_bio_X509
359             #define X509_get_tbs_sigalg(c) (X509_ALGOR*)X509_get0_tbs_sigalg(c)
360             #define X509_get_signature X509_get0_signature
361             #define X509_get_subject_key_id X509_get0_subject_key_id
362             #define X509_get_authority_key_id X509_get0_authority_key_id
363             #define X509_get_authority_serial X509_get0_authority_serial
364             #define X509_set_notAfter X509_set1_notAfter
365             #define X509_set_notBefore X509_set1_notBefore
366             #define X509_get_distinguishing_id X509_get0_distinguishing_id
367             #define X509_set_distinguishing_id X509_set0_distinguishing_id
368             #define X509_EXTENSION_get_data X509_EXTENSION_get_data
369             #define X509_ATTRIBUTE_get_data X509_ATTRIBUTE_get0_data
370             #define X509_ATTRIBUTE_set_data X509_ATTRIBUTE_set1_data
371             #define X509_ATTRIBUTE_get_object X509_ATTRIBUTE_get0_object
372             #define X509_ATTRIBUTE_set_object X509_ATTRIBUTE_set1_object
373             #undef X509_NAME_hash
374             #define X509_NAME_hash X509_NAME_hash_ex
375             #define X509_NAME_print X509_NAME_print_ex
376             #define EDIPARTYNAME_get_name_assigner(edi) edi->nameAssigner
377             #define EDIPARTYNAME_get_party_name(edi) edi->partyName
378 0           SV* S_EDIPARTYNAME_to_string(pTHX_ EDIPARTYNAME* edi) {
379 0           SV* result = ASN1_STRING_to_SV(V_ASN1_OCTET_STRING, edi->partyName);
380 0 0         if (edi->nameAssigner) {
381 0           sv_catpvs(result, "@");
382 0           const unsigned char* data = ASN1_STRING_get0_data(edi->nameAssigner);
383 0           int length = ASN1_STRING_length(edi->nameAssigner);
384 0           sv_catpvn(result, data, length);
385             }
386 0           return result;
387             }
388             #define EDIPARTYNAME_to_string(edi) S_EDIPARTYNAME_to_string(aTHX_ edi)
389             #define GENERAL_NAME_new_from_x509_name GENERAL_NAME_set1_X509_NAME
390             #define GENERAL_NAME_type(gn) (gn->type)
391             #define X509_STORE_load_file X509_STORE_load_file_ex
392             #define X509_STORE_load_store X509_STORE_load_store_ex
393             #define X509_ALGOR_get X509_ALGOR_get0
394             #define X509_ALGOR_set X509_ALGOR_set0
395             #define X509_verify_cert_error_code(value) value
396             #define X509_verify_cert_ok(value) (value == X509_V_OK)
397             #define X509_VERIFY_PARAM_add_policy X509_VERIFY_PARAM_add0_policy
398             #define X509_VERIFY_PARAM_set_policies X509_VERIFY_PARAM_set1_policies
399             #define X509_VERIFY_PARAM_get_host X509_VERIFY_PARAM_get0_host
400             #define X509_VERIFY_PARAM_set_host X509_VERIFY_PARAM_set1_host
401             #define X509_VERIFY_PARAM_add_host X509_VERIFY_PARAM_add1_host
402             #define X509_VERIFY_PARAM_get_peername X509_VERIFY_PARAM_get0_peername
403             #define X509_VERIFY_PARAM_get_email X509_VERIFY_PARAM_get0_email
404             #define X509_VERIFY_PARAM_set_email X509_VERIFY_PARAM_set1_email
405             #define X509_VERIFY_PARAM_get_ip_asc X509_VERIFY_PARAM_get1_ip_asc
406             #define X509_VERIFY_PARAM_set_ip X509_VERIFY_PARAM_set1_ip
407             #define X509_VERIFY_PARAM_set_ip_asc X509_VERIFY_PARAM_set1_ip_asc
408             #define X509_STORE_CTX_new X509_STORE_CTX_new_ex
409             #define X509_STORE_CTX_get_cert X509_STORE_CTX_get0_cert
410             #undef X509_STORE_CTX_get_chain
411             #define X509_STORE_CTX_get_chain X509_STORE_CTX_get1_chain
412             #define X509_STORE_CTX_get_param X509_STORE_CTX_get0_param
413             #define X509_STORE_CTX_get_rpk X509_STORE_CTX_get0_rpk
414             #define X509_STORE_CTX_get_untrusted X509_STORE_CTX_get0_untrusted
415             #define X509_STORE_CTX_set_param X509_STORE_CTX_set0_param
416             #define X509_STORE_CTX_set_rpk X509_STORE_CTX_set0_rpk
417             #define X509_STORE_CTX_set_trusted_stack X509_STORE_CTX_set0_trusted_stack
418             #define X509_STORE_CTX_set_untrusted X509_STORE_CTX_set0_untrusted
419             #define X509_STORE_CTX_set_verified_chain X509_STORE_CTX_set0_verified_chain
420             #define X509_REQ_new X509_REQ_new_ex
421             #define X509_REQ_read_der d2i_X509_REQ_bio
422             #define X509_REQ_write_der i2d_X509_REQ_bio
423             #define X509_REQ_read_pem PEM_read_bio_X509_REQ
424             #define X509_REQ_write_pem PEM_write_bio_X509_REQ
425             #define X509_REQ_add_attr X509_REQ_add1_attr
426             #define X509_REQ_add_attr_by_NID X509_REQ_add1_attr_by_NID
427             #define X509_REQ_add_attr_by_OBJ X509_REQ_add1_attr_by_OBJ
428             #define X509_REQ_add_attr_by_txt X509_REQ_add1_attr_by_txt
429             #define X509_REQ_get_X509_pubkey X509_REQ_get_X509_PUBKEY
430             #define X509_REQ_get_distinguishing_id X509_REQ_get0_distinguishing_id
431             #define X509_REQ_set_distinguishing_id X509_REQ_set0_distinguishing_id
432             #define X509_REQ_get_signature X509_REQ_get0_signature
433             #define X509_REQ_set_signature X509_REQ_set0_signature
434             #define X509_REQ_set_signature_algo X509_REQ_set1_signature_algo
435             #define X509_REQ_verify X509_REQ_verify_ex
436              
437             #define CTLOG_STORE_new CTLOG_STORE_new_ex
438             #define CT_POLICY_EVAL_CTX_new CT_POLICY_EVAL_CTX_new_ex
439             #define CT_POLICY_EVAL_CTX_get_cert CT_POLICY_EVAL_CTX_get0_cert
440             #define CT_POLICY_EVAL_CTX_set_cert CT_POLICY_EVAL_CTX_set1_cert
441             #define CT_POLICY_EVAL_CTX_get_issuer CT_POLICY_EVAL_CTX_get0_issuer
442             #define CT_POLICY_EVAL_CTX_set_issuer CT_POLICY_EVAL_CTX_set1_issuer
443             #define CT_POLICY_EVAL_CTX_set_log_store CT_POLICY_EVAL_CTX_set_shared_CTLOG_STORE
444             #define SCT_get_log_id SCT_get0_log_id
445             #define SCT_get_signature SCT_get0_signature
446             #define SCT_get_extensions SCT_get0_extensions
447             #define SCT_set_log_id SCT_set1_log_id
448             #define SCT_set_signature SCT_set1_signature
449             #define SCT_set_extensions SCT_set1_extensions
450              
451             #define PKCS7_new PKCS7_new_ex
452             #define PKCS7_read_pem PEM_read_bio_PKCS7
453             #define PKCS7_write_pem PEM_write_bio_PKCS7
454             #define PKCS7_read_der d2i_PKCS7_bio
455             #define PKCS7_write_der i2d_PKCS7_bio
456             #define PKCS7_sign PKCS7_sign_ex
457             #define PKCS7_encrypt PKCS7_encrypt_ex
458              
459             #define TS_REQ_print(t, b) TS_REQ_print_bio(b, t)
460             #define TS_REQ_read_der d2i_TS_REQ_bio
461             #define TS_REQ_write_der i2d_TS_REQ_bio
462             #define TS_REQ_get_nonce TS_REQ_get_nonce
463             #define TS_TST_INFO_print(t, b) TS_TST_INFO_print_bio(b, t)
464             #define TS_TST_INFO_read_der d2i_TS_TST_INFO_bio
465             #define TS_TST_INFO_write_der i2d_TS_TST_INFO_bio
466             #define TS_RESP_print(t, b) TS_RESP_print_bio(b, t)
467             #define TS_RESP_read_der d2i_TS_RESP_bio
468             #define TS_RESP_write_der i2d_TS_RESP_bio
469             #define TS_MSG_IMPRINT_print(t, b) TS_MSG_IMPRINT_print_bio(b, t)
470             #define TS_MSG_IMPRINT_read_der d2i_TS_MSG_IMPRINT_bio
471             #define TS_MSG_IMPRINT_write_der i2d_TS_MSG_IMPRINT_bio
472             #define TS_STATUS_INFO_get_status TS_STATUS_INFO_get0_status
473             #define TS_STATUS_INFO_get_failure_info TS_STATUS_INFO_get0_failure_info
474             #define TS_RESP_CTX_new TS_RESP_CTX_new_ex
475             #define TS_RESP_CTX_create_response TS_RESP_create_response
476             #define TS_VERIFY_CTX_init_from_request(ctx, req) TS_REQ_to_TS_VERIFY_CTX(req, ctx)
477             #if OPENSSL_VERSION_PREREQ(3, 4)
478             #define TS_VERIFY_CTX_set_data TS_VERIFY_CTX_set0_data
479             #define TS_VERIFY_CTX_set_imprint TS_VERIFY_CTX_set0_imprint
480             #define TS_VERIFY_CTX_set_store TS_VERIFY_CTX_set0_store
481             #define TS_VERIFY_CTX_set_certs TS_VERIFY_CTX_set0_certs
482             #endif
483             #define TS_VERIFY_CTX_verify_response TS_RESP_verify_response
484             #define TS_VERIFY_CTX_verify_token TS_RESP_verify_token
485              
486             #define SSL_Method_TLS TLS_method
487             #define SSL_Method_TLS_server TLS_server_method
488             #define SSL_Method_TLS_client TLS_client_method
489              
490             #define SSL_Method_DTLS DTLS_method
491             #define SSL_Method_DTLS_server DTLS_server_method
492             #define SSL_Method_DTLS_client DTLS_client_method
493              
494             #define SSL_Method_QUIC_client OSSL_QUIC_client_method
495             #define SSL_Method_QUIC_client_thread OSSL_QUIC_client_thread_method
496             #define SSL_Method_QUIC_server OSSL_QUIC_server_method
497              
498             #define SSL_CTX_get_param SSL_CTX_get0_param
499             #define SSL_CTX_set_param SSL_CTX_set1_param
500              
501             #define SSL_set_host SSL_set1_host
502             #define SSL_set_dnsname SSL_set1_dnsname
503             #define SSL_set_ipaddr SSL_set1_ipaddr
504             #define SSL_set_rbio SSL_set0_rbio
505             #define SSL_set_wbio SSL_set0_wbio
506             #define SSL_get_context SSL_get_SSL_CTX
507             #define SSL_get_alpn_selected SSL_get0_alpn_selected
508             #define SSL_get_connection SSL_get0_connection
509             #define SSL_get_listener SSL_get0_listener
510             #define SSL_get_domain SSL_get0_domain
511             #define SSL_set_initial_peer_addr SSL_set1_initial_peer_addr
512             #define SSL_get_param SSL_get0_param
513             #define SSL_set_param SSL_set1_param
514             #if !OPENSSL_VERSION_PREREQ(3, 2)
515             #define SSL_is_tls(s) (!SSL_is_dtls(s))
516             #define SSL_is_quic(s) FALSE
517             #endif
518              
519             #define SSL_SESSION_read_der d2i_SSL_SESSION_bio
520             #define SSL_SESSION_write_der i2d_SSL_SESSION_bio
521             #define SSL_SESSION_get_peer SSL_SESSION_get0_peer
522             #define SSL_SESSION_get_alpn_selected SSL_SESSION_get0_alpn_selected
523             #define SSL_SESSION_get_cipher SSL_SESSION_get0_cipher
524             #define SSL_SESSION_get_hostname SSL_SESSION_get0_hostname
525             #define SSL_SESSION_get_id_context SSL_SESSION_get0_id_context
526             #define SSL_SESSION_get_ticket SSL_SESSION_get0_ticket
527             #define SSL_SESSION_set_alpn_selected SSL_SESSION_set1_alpn_selected
528             #define SSL_SESSION_set_hostname SSL_SESSION_set1_hostname
529             #define SSL_SESSION_set_id SSL_SESSION_set1_id
530             #define SSL_SESSION_set_id_context SSL_SESSION_set1_id_context
531             #if !OPENSSL_VERSION_PREREQ(3,2)
532             #define SSL_get_event_timeout(s, tv, inf) DTLSv1_get_timeout(s, tv)
533             #define SSL_handle_events DTLSv1_handle_timeout
534             #endif
535             #if OPENSSL_VERSION_PREREQ(3, 3)
536             #define SSL_SESSION_get_time SSL_SESSION_get_time_ex
537             #define SSL_SESSION_set_time SSL_SESSION_set_time_ex
538             #endif
539              
540             #define NID_create OBJ_create
541             #define NID_from_long_name OBJ_ln2nid
542             #define NID_from_short_name OBJ_sn2nid
543             #define NID_from_text OBJ_txt2nid
544             #define NID_get_long_name OBJ_nid2ln
545             #define NID_get_short_name OBJ_nid2sn
546             #define NID_to_object OBJ_nid2obj
547             #define NID_eq(left, right) (left == right)
548             #define NID_raw(nid) nid
549             #define NID_is_undef(nid) (nid == NID_undef)
550              
551             #define SSL_CIPHER_get_handshake_digest(c) (EVP_MD*)SSL_CIPHER_get_handshake_digest(c)
552              
553             #define RAND_get_primary RAND_get0_primary
554             #define RAND_get_public RAND_get0_public
555             #define RAND_get_private RAND_get0_private
556             #define RAND_set_public RAND_set0_public
557             #define RAND_set_private RAND_set0_private
558             #define EVP_RAND_get_name EVP_RAND_get0_name
559             #define EVP_RAND_get_description EVP_RAND_get0_description
560             #define EVP_RAND_CTX_get_rand EVP_RAND_CTX_get0_rand
561             #define EVP_CIPHER_get_name EVP_CIPHER_get0_name
562             #define EVP_CIPHER_get_description EVP_CIPHER_get0_description
563             #undef EVP_CIPHER_CTX_init
564             #define EVP_CIPHER_CTX_init EVP_CipherInit_ex2
565             #define EVP_CIPHER_CTX_update EVP_CipherUpdate
566             #define EVP_CIPHER_CTX_final EVP_CipherFinal_ex
567             #define EVP_CIPHER_CTX_set_aead_ivlen(ctx, length) EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_IVLEN, length, NULL)
568             #define EVP_CIPHER_CTX_get_aead_tag(ctx, ptr, length) EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_GET_TAG, length, ptr)
569             #define EVP_CIPHER_CTX_set_aead_tag(ctx, ptr, length) EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_TAG, length, ptr)
570             #define EVP_CIPHER_CTX_get_name EVP_CIPHER_CTX_get0_name
571             #define EVP_CIPHER_CTX_get_cipher EVP_CIPHER_CTX_get1_cipher
572              
573             #define EVP_MD_digest EVP_Digest
574             #define EVP_MD_get_name EVP_MD_get0_name
575             #define EVP_MD_get_description EVP_MD_get0_description
576             #undef EVP_MD_CTX_init
577             #define EVP_MD_CTX_get_md EVP_MD_CTX_get1_md
578             #define EVP_MD_CTX_get_name EVP_MD_CTX_get0_name
579             #define EVP_MD_CTX_init EVP_DigestInit_ex2
580             #define EVP_MD_CTX_update EVP_DigestUpdate
581             #define EVP_MD_CTX_final EVP_DigestFinal_ex
582             #define EVP_MD_CTX_final_xof EVP_DigestFinalXOF
583             #define EVP_MD_CTX_squeeze EVP_DigestSqueeze
584             #define EVP_MD_CTX_sign_init EVP_DigestSignInit
585             #define EVP_MD_CTX_sign_init_ex EVP_DigestSignInit_ex
586             #define EVP_MD_CTX_sign_update EVP_DigestSignUpdate
587             #define EVP_MD_CTX_sign_final EVP_DigestSignFinal
588             #define EVP_MD_CTX_sign EVP_DigestSign
589             #define EVP_MD_CTX_verify_init EVP_DigestVerifyInit
590             #define EVP_MD_CTX_verify_update EVP_DigestVerifyUpdate
591             #define EVP_MD_CTX_verify_final EVP_DigestVerifyFinal
592             #define EVP_MD_CTX_verify EVP_DigestVerify
593              
594             #define EVP_MAC_get_name EVP_MAC_get0_name
595             #define EVP_MAC_get_description EVP_MAC_get0_description
596             #define EVP_MAC_CTX_get_mac EVP_MAC_CTX_get0_mac
597             #define EVP_MAC_CTX_get_name EVP_MAC_CTX_get0_name
598              
599             #define EVP_KDF_get_name EVP_KDF_get0_name
600             #define EVP_KDF_get_description EVP_KDF_get0_description
601             #define EVP_KDF_CTX_get_name EVP_KDF_CTX_get0_name
602             #define EVP_KDF_CTX_kdf(ctx) (EVP_KDF*)EVP_KDF_CTX_kdf(ctx)
603              
604             #define EVP_SIGNATURE_get_name EVP_SIGNATURE_get0_name
605             #define EVP_SIGNATURE_get_description EVP_SIGNATURE_get0_description
606              
607             #define EVP_PKEY_read_pem_private_key PEM_read_bio_PrivateKey_ex
608             #define EVP_PKEY_write_pem_private_key PEM_write_bio_PrivateKey_ex
609             #define EVP_PKEY_read_pem_public_key PEM_read_bio_PUBKEY_ex
610             #define EVP_PKEY_write_pem_public_key PEM_write_bio_PUBKEY_ex
611             #define EVP_PKEY_read_der_private_key d2i_PrivateKey_ex_bio
612             #define EVP_PKEY_write_der_private_key i2d_PrivateKey_bio
613             #if !OPENSSL_VERSION_PREREQ(3, 2)
614             #define d2i_PUBKEY_ex_bio(bio, ptr, lib, propq) d2i_PUBKEY_bio(bio, ptr)
615             #endif
616             #define EVP_PKEY_read_der_public_key d2i_PUBKEY_ex_bio
617             #define EVP_PKEY_write_der_public_key i2d_PUBKEY_bio
618             #define EVP_PKEY_new_raw_private_key EVP_PKEY_new_raw_private_key_ex
619             #define EVP_PKEY_new_raw_public_key EVP_PKEY_new_raw_public_key_ex
620             #define EVP_PKEY_get_description EVP_PKEY_get0_description
621             #define EVP_PKEY_get_type_name EVP_PKEY_get0_type_name
622             #define EVP_PKEY_get_encoded_public_key EVP_PKEY_get1_encoded_public_key
623             #define EVP_PKEY_set_encoded_public_key EVP_PKEY_set1_encoded_public_key
624             #define EVP_PKEY_encrypt_init EVP_PKEY_encrypt_init_ex
625             #define EVP_PKEY_decrypt_init EVP_PKEY_decrypt_init_ex
626             #define EVP_PKEY_derive_init EVP_PKEY_derive_init_ex
627             #define EVP_PKEY_derive_set_peer EVP_PKEY_derive_set_peer_ex
628             #define EVP_PKEY_CTX_get_pkey EVP_PKEY_CTX_get0_pkey
629             #define EVP_PKEY_CTX_get_peerkey EVP_PKEY_CTX_get0_peerkey
630              
631             #if !OPENSSL_VERSION_PREREQ(3, 4)
632 0           static int EVP_PKEY_sign_init_ex2(EVP_PKEY_CTX *ctx, EVP_SIGNATURE *algo, const OSSL_PARAM params[]) {
633 0 0         if (algo)
634 0           return FALSE;
635 0           return EVP_PKEY_sign_init_ex(ctx, params);
636             }
637              
638 0           static int EVP_PKEY_verify_init_ex2(EVP_PKEY_CTX *ctx, EVP_SIGNATURE *algo, const OSSL_PARAM params[]) {
639 0 0         if (algo)
640 0           return FALSE;
641 0           return EVP_PKEY_verify_init_ex(ctx, params);
642             }
643             #endif
644             #define EVP_PKEY_sign_init EVP_PKEY_sign_init_ex2
645             #define EVP_PKEY_verify_init EVP_PKEY_verify_init_ex2
646              
647              
648             #if OPENSSL_VERSION_PREREQ(3, 2)
649             #define OSSL_HPKE_CTX_set_authpriv OSSL_HPKE_CTX_set1_authpriv
650             #define OSSL_HPKE_CTX_set_authpub OSSL_HPKE_CTX_set1_authpub
651             #define OSSL_HPKE_CTX_set_psk OSSL_HPKE_CTX_set1_psk
652             #define OSSL_HPKE_CTX_set_ikme OSSL_HPKE_CTX_set1_ikme
653             #define OSSL_HPKE_decapsulate OSSL_HPKE_decap
654             #define OSSL_HPKE_check OSSL_HPKE_suite_check
655             #define OSSL_HPKE_kem_id(suite) (suite)->kem_id
656             #define OSSL_HPKE_kdf_id(suite) (suite)->kdf_id
657             #define OSSL_HPKE_aead_id(suite) (suite)->aead_id
658             #endif
659              
660             #define CONSTANT2(PREFIX, VALUE) newCONSTSUB(stash, #VALUE, newSVuv(PREFIX##VALUE))
661              
662             #define STACK_TO_STACK(TYPE, stack) \
663             if (stack) {\
664             int num = sk_ ## TYPE ## _num(stack);\
665             EXTEND(SP, num);\
666             for (int i = 0; i < num; ++i) {\
667             TYPE* value = sk_ ## TYPE ## _delete(stack, 0);\
668             mPUSHs(make_ ## TYPE(aTHX_ value));\
669             }\
670             sk_ ## TYPE ## _free(stack);\
671             }
672              
673             #define CSTACK_TO_STACK(TYPE, stack) \
674             if (stack) {\
675             int num = sk_ ## TYPE ## _num(stack);\
676             EXTEND(SP, num);\
677             for (int i = 0; i < num; ++i) {\
678             TYPE* orig = sk_ ## TYPE ## _value(stack, i);\
679             TYPE* value = TYPE ## _dup(orig);\
680             mPUSHs(make_ ## TYPE(aTHX_ value));\
681             }\
682             }
683              
684             #define STACK_FROM_ARRAY(TYPE, var, arg)\
685             var = sk_ ## TYPE ## _new(NULL);\
686             if (SvROK(arg) && SvTYPE(SvRV(arg)) == SVt_PVAV) {\
687             for (int i = 0; i < av_count((AV*)SvRV(arg)); ++i) {\
688             TYPE* value = get_ ## TYPE(aTHX_ *av_fetch((AV*)SvRV(arg), i, FALSE));\
689             if (value)\
690             sk_ ## TYPE ## _push(var, value);\
691             }\
692             }
693              
694 7           static OSSL_PARAM* S_params_for(pTHX_ const OSSL_PARAM* settable, SV* input) {
695 7 50         if (!SvROK(input) || SvTYPE(SvRV(input)) != SVt_PVHV)
    50          
696 0           return NULL;
697              
698 7           OSSL_PARAM_BLD* builder = OSSL_PARAM_BLD_new();
699 7           HV* hash = (HV*)SvRV(input);
700              
701 7           hv_iterinit(hash);
702             char* name;
703             I32 name_len;
704             SV* sv;
705              
706 19 100         while (sv = hv_iternextsv(hash, &name, &name_len)) {
707 12           const OSSL_PARAM* found = OSSL_PARAM_locate_const(settable, name);
708              
709 12 100         if (found) {
710             const BIGNUM* big;
711 11 50         if (found->data_type == OSSL_PARAM_INTEGER) {
712 0 0         if (big = get_BN(aTHX_ sv))
713 0           OSSL_PARAM_BLD_push_BN(builder, found->key, big);
714             else
715 0           OSSL_PARAM_BLD_push_int64(builder, found->key, SvIV(sv));
716 11 100         } else if (found->data_type == OSSL_PARAM_UNSIGNED_INTEGER) {
717 6 50         if (big = get_BN(aTHX_ sv))
718 0           OSSL_PARAM_BLD_push_BN(builder, found->key, big);
719             else
720 6           OSSL_PARAM_BLD_push_uint64(builder, found->key, SvUV(sv));
721 5 50         } else if (found->data_type == OSSL_PARAM_REAL) {
722 0           OSSL_PARAM_BLD_push_double(builder, found->key, SvNV(sv));
723 5 100         } else if (found->data_type == OSSL_PARAM_UTF8_STRING) {
724             STRLEN length;
725 4           const char* ptr = SvPVutf8(sv, length);
726 4           OSSL_PARAM_BLD_push_utf8_string(builder, found->key, ptr, length);
727 1 50         } else if (found->data_type == OSSL_PARAM_OCTET_STRING) {
728             STRLEN length;
729 1           const char* ptr = SvPVbyte(sv, length);
730 1           OSSL_PARAM_BLD_push_octet_string(builder, found->key, ptr, length);
731             }
732             }
733             }
734              
735 7           OSSL_PARAM* result = OSSL_PARAM_BLD_to_param(builder);
736 7           OSSL_PARAM_BLD_free(builder);
737 7           SAVEDESTRUCTOR(OSSL_PARAM_free, result);
738 7           return result;
739             }
740             #define params_for(settable, sv) S_params_for(aTHX_ settable, sv)
741              
742 1           static SV* S_make_param_scalar(pTHX_ OSSL_PARAM* iter) {
743 1 50         if (iter->data_type == OSSL_PARAM_INTEGER) {
744 0 0         if (iter->data_size == 0)
745 0           return newSViv(0);
746 0 0         else if (iter->data_size <= IVSIZE) {
747             int64_t value;
748 0           OSSL_PARAM_get_int64(iter, &value);
749 0           return newSViv(value);
750             } else {
751 0           BIGNUM* value = NULL;
752 0           OSSL_PARAM_get_BN(iter, &value);
753 0           return make_BN(aTHX_ value);
754             }
755             }
756 1 50         else if (iter->data_type == OSSL_PARAM_UNSIGNED_INTEGER) {
757 1 50         if (iter->data_size == 0)
758 0           return newSVuv(0);
759 1 50         else if (iter->data_size <= UVSIZE) {
760 1           uint64_t value = 0;
761 1           OSSL_PARAM_get_uint64(iter, &value);
762 1           return newSVuv(value);
763             } else {
764 0           BIGNUM* value = NULL;
765 0           OSSL_PARAM_get_BN(iter, &value);
766 0           return make_BN(aTHX_ value);
767             }
768             }
769 0 0         else if (iter->data_type == OSSL_PARAM_REAL) {
770             double value;
771 0           OSSL_PARAM_get_double(iter, &value);
772 0           return newSVnv(value);
773             }
774 0 0         else if (iter->data_type == OSSL_PARAM_UTF8_STRING) {
775 0           return newSVpvn_utf8((const char*)iter->data, iter->data_size, 1);
776             }
777 0 0         else if (iter->data_type == OSSL_PARAM_OCTET_STRING) {
778 0           return newSVpvn((const char*)iter->data, iter->data_size);
779             }
780              
781 0           return NULL;
782             }
783             #define make_param_scalar(params) S_make_param_scalar(aTHX_ params)
784              
785             #define GENERATE_GET_PARAM(prefix, arg, name)\
786             RETVAL = &PL_sv_undef;\
787             const OSSL_PARAM* description = OSSL_PARAM_locate_const(prefix ## _gettable_params(arg), name);\
788             if (description) {\
789             OSSL_PARAM params[] = {\
790             OSSL_PARAM_DEFN(description->key, description->data_type, NULL, SIZE_MAX),\
791             OSSL_PARAM_END,\
792             };\
793             if (prefix ## _get_params(arg, params)) {\
794             void* data = NULL;\
795             if (OSSL_PARAM_modified(params)) {\
796             data = params->data = OPENSSL_zalloc(params->return_size);\
797             params->data_size = params->return_size;\
798             }\
799             if (prefix ## _get_params(arg, params))\
800             RETVAL = make_param_scalar(params);\
801             OPENSSL_free(data);\
802             }\
803             }
804              
805             #ifdef MULTIPLICITY
806             #define iTHX aTHX
807             #else
808             #define iTHX NULL
809             #endif
810              
811 0           static void EVP_name_callback(const char* name, void* vdata) {
812             dTHXa((PerlInterpreter*)vdata);
813 0           dSP;
814 0 0         mXPUSHp(name, strlen(name));
815 0           PUTBACK;
816 0           }
817              
818             #define DEFINE_PROVIDED_CALLBACK(c_type)\
819             static inline void c_type ## _provided_callback(c_type* provided, void* vdata) {\
820             dTHXa((PerlInterpreter*)vdata);\
821             c_type ## _up_ref(provided);\
822             SV* object = make_ ## c_type(aTHX_ provided);\
823             dSP;\
824             mXPUSHs(object);\
825             PUTBACK;\
826             }
827 0 0         DEFINE_PROVIDED_CALLBACK(EVP_RAND)
828 124 50         DEFINE_PROVIDED_CALLBACK(EVP_CIPHER)
829 22 50         DEFINE_PROVIDED_CALLBACK(EVP_MD)
830 9 50         DEFINE_PROVIDED_CALLBACK(EVP_MAC)
831 12 50         DEFINE_PROVIDED_CALLBACK(EVP_KDF)
832 0 0         DEFINE_PROVIDED_CALLBACK(EVP_SIGNATURE)
833              
834 0           static ASN1_INTEGER* TS_RESP_CTX_serial_callback(struct TS_resp_ctx* ctx, void* data) {
835             dTHX;
836 0           dSP;
837              
838 0           SV* callback = (SV*)data;
839 0           ENTER;
840 0           SAVETMPS;
841 0 0         PUSHMARK(sp);
842 0           int ret = call_sv(callback, G_SCALAR | G_EVAL);
843 0 0         if (ret != 1) {
844 0           TS_RESP_CTX_set_status_info(ctx, TS_STATUS_REJECTION, "Error during serial number generation");
845 0 0         FREETMPS;
846 0           LEAVE;
847 0           return NULL;
848             }
849 0           SV* returnee = POPs;
850 0           ASN1_INTEGER* result = ASN1_INTEGER_from_SV(returnee);
851 0 0         FREETMPS;
852 0           LEAVE;
853 0           return result;
854             }
855              
856 0           static int TS_RESP_CTX_time_callback(struct TS_resp_ctx* ctx, void* data, long *sec, long *usec) {
857             dTHX;
858 0           dSP;
859              
860 0           SV* callback = (SV*)data;
861 0           ENTER;
862 0           SAVETMPS;
863 0 0         PUSHMARK(sp);
864 0           int ret = call_sv(callback, G_LIST | G_EVAL);
865 0 0         if (ret != 1 && ret != 2) {
    0          
866 0           TS_RESP_CTX_set_status_info(ctx, TS_STATUS_REJECTION, "Time is not available");
867 0           TS_RESP_CTX_add_failure_info(ctx, TS_INFO_TIME_NOT_AVAILABLE);
868 0 0         FREETMPS;
869 0           LEAVE;
870 0           return 0;
871             }
872              
873 0 0         *usec = ret == 2 ? POPi : 0;
874 0           *sec = POPi;
875 0 0         FREETMPS;
876 0           LEAVE;
877 0           return 1;
878             }
879              
880             typedef int Bool;
881             typedef int Success;
882             typedef int PrintRet;
883             #define undef &PL_sv_undef
884              
885             #define CLONE_SKIP(...) 1
886              
887             // This will force byte semantics on all strings
888             // This should come as the last thing in the C section of this file
889             #undef SvPV
890             #define SvPV(sv, len) SvPVbyte(sv, len)
891             #undef SvPV_nolen
892             #define SvPV_nolen(sv) SvPVbyte_nolen(sv)
893              
894             MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3 PREFIX = OpenSSL_
895              
896             REQUIRE: 3.63
897              
898             PROTOTYPES: DISABLE
899              
900             TYPEMAP: <
901             const unsigned char* T_PV
902             Bool T_BOOL
903             struct timeval T_TIMEVAL
904             int64_t T_IV
905             uint32_t T_UV
906             uint64_t T_UV
907             Success T_SUCCESS
908             PrintRet T_PRINT
909             HV* T_HVREF_REFCOUNT_FIXED
910              
911             ASN1_DECODER* T_ASN1_DECODER
912              
913             ASN1_OCTET_STRING* T_ASN1_STRING
914             ASN1_BIT_STRING* T_ASN1_STRING
915             ASN1_UTF8STRING* T_ASN1_STRING
916             const ASN1_OCTET_STRING* T_ASN1_STRING
917             const ASN1_BIT_STRING* T_ASN1_STRING
918             const ASN1_UTF8STRING* T_ASN1_STRING
919             ASN1_INTEGER* T_ASN1_INTEGER
920             const ASN1_INTEGER* T_ASN1_INTEGER
921             ASN1_TIME* T_ASN1_TIME
922             const ASN1_GENERALIZEDTIME* T_ASN1_GENERALIZEDTIME
923              
924             Crypt::OpenSSL3::Random T_MAGICEXT
925             Crypt::OpenSSL3::Random::Context T_MAGICEXT
926             Crypt::OpenSSL3::Cipher T_MAGICEXT
927             Crypt::OpenSSL3::Cipher::Context T_MAGICEXT
928             Crypt::OpenSSL3::MD T_MAGICEXT
929             Crypt::OpenSSL3::MD::Context T_MAGICEXT
930             Crypt::OpenSSL3::MAC T_MAGICEXT
931             Crypt::OpenSSL3::MAC::Context T_MAGICEXT
932             Crypt::OpenSSL3::KDF T_MAGICEXT
933             Crypt::OpenSSL3::KDF::Context T_MAGICEXT
934             Crypt::OpenSSL3::Signature T_MAGICEXT
935             Crypt::OpenSSL3::PKey T_MAGICEXT
936             Crypt::OpenSSL3::PKey::Context T_MAGICEXT
937              
938             Crypt::OpenSSL3::BIO T_MAGICEXT
939             Crypt::OpenSSL3::BIO::Address T_MAGICEXT
940             Crypt::OpenSSL3::BIO::PollDescriptor T_MAGICBUF
941             Crypt::OpenSSL3::Error T_INTOBJ
942              
943             Crypt::OpenSSL3::BigNum T_MAGICEXT
944             Crypt::OpenSSL3::BigNum::Context T_MAGICEXT
945              
946             Crypt::OpenSSL3::ASN1::Decoder T_MAGICEXT
947             Crypt::OpenSSL3::ASN1::Value T_MAGICEXT
948             Crypt::OpenSSL3::ASN1::Object T_MAGICEXT
949              
950             Crypt::OpenSSL3::X509 T_MAGICEXT
951             Crypt::OpenSSL3::X509::Stack T_MAGICEXT
952             Crypt::OpenSSL3::X509::Store T_MAGICEXT
953             Crypt::OpenSSL3::X509::Store::Context T_MAGICEXT
954             Crypt::OpenSSL3::X509::Name T_MAGICEXT
955             Crypt::OpenSSL3::X509::Name::Entry T_MAGICEXT
956             Crypt::OpenSSL3::X509::Algorithm T_MAGICEXT
957             Crypt::OpenSSL3::X509::VerifyResult T_INTOBJ
958             Crypt::OpenSSL3::X509::EDIPartyName T_MAGICEXT
959             Crypt::OpenSSL3::X509::GeneralName T_MAGICEXT
960             Crypt::OpenSSL3::X509::Extension T_MAGICEXT
961             Crypt::OpenSSL3::X509::Attribute T_MAGICEXT
962             Crypt::OpenSSL3::X509::VerifyParam T_MAGICEXT
963             Crypt::OpenSSL3::X509::Request T_MAGICEXT
964              
965             STACK_OF(X509)* T_STACK
966             STACK_OF(X509_EXTENSION)* T_STACK
967             STACK_OF(ASN1_OBJECT)* T_STACK
968              
969             Crypt::OpenSSL3::X509::Transparency::Timestamp T_MAGICEXT
970             Crypt::OpenSSL3::X509::Transparency::Log::Store T_MAGICEXT
971             Crypt::OpenSSL3::X509::Transparency::Evaluator T_MAGICEXT
972              
973             Crypt::OpenSSL3::PKCS7 T_MAGICEXT
974              
975             Crypt::OpenSSL3::Timestamp::Request T_MAGICEXT
976             Crypt::OpenSSL3::Timestamp::Response T_MAGICEXT
977             Crypt::OpenSSL3::Timestamp::Imprint T_MAGICEXT
978             Crypt::OpenSSL3::Timestamp::TokenInfo T_MAGICEXT
979             Crypt::OpenSSL3::Timestamp::StatusInfo T_MAGICEXT
980             Crypt::OpenSSL3::Timestamp::Accuracy T_MAGICEXT
981             Crypt::OpenSSL3::Timestamp::Responder T_MAGICEXT
982             Crypt::OpenSSL3::Timestamp::Verifier T_MAGICEXT
983              
984             Crypt::OpenSSL3::SSL::Method T_MAGICEXT
985             Crypt::OpenSSL3::SSL::Context T_MAGICEXT
986             Crypt::OpenSSL3::SSL T_MAGICEXT
987             Crypt::OpenSSL3::SSL::Session T_MAGICEXT
988             Crypt::OpenSSL3::SSL::Cipher T_MAGICEXT
989             Crypt::OpenSSL3::NID T_INTOBJ
990              
991             Crypt::OpenSSL3::HPKE T_MAGICBUF
992             Crypt::OpenSSL3::HPKE::Context T_MAGICEXT
993              
994             OSSL_PARAM* T_OSSL_PARAMS
995             PARAMS(EVP_RAND_CTX) T_PARAMS
996             PARAMS(EVP_CIPHER_CTX) T_PARAMS
997             CTX_PARAMS(EVP_CIPHER) T_CTX_PARAMS
998             PARAMS(EVP_MD_CTX) T_PARAMS
999             CTX_PARAMS(EVP_MD) T_CTX_PARAMS
1000             PARAMS(EVP_MAC_CTX) T_PARAMS
1001             PARAMS(EVP_KDF_CTX) T_PARAMS
1002             PARAMS(EVP_PKEY) T_PARAMS
1003             PARAMS(EVP_PKEY_CTX) T_PARAMS
1004             CTX_PARAMS(EVP_SIGNATURE) T_CTX_PARAMS
1005              
1006             INPUT
1007             T_PARAMS
1008             const OSSL_PARAM* settable = ${ \($type =~ s/ PARAMS \( (\w+) \) /$1_settable_params(ctx)/xr) };
1009             $var = params_for(settable, $arg);
1010              
1011             T_CTX_PARAMS
1012             const OSSL_PARAM* settable = ${ \($type =~ s/ CTX_PARAMS \( (\w+) \) /$1_settable_ctx_params(type)/xr) };
1013             $var = params_for(settable, $arg);
1014              
1015             T_ASN1_DECODER
1016             if (SvROK($arg)) {
1017             MAGIC* magic = mg_findext(SvRV($arg), PERL_MAGIC_ext, &Crypt__OpenSSL3__ASN1__Decoder_magic);
1018             if (magic)
1019             $var = (ASN1_DECODER*)magic->mg_ptr;
1020             else
1021             croak("%s object is lacking magic", "$ntype");
1022             } else {
1023             $var = safecalloc(1, sizeof(ASN1_DECODER));
1024             SAVEFREEPV($var);
1025             size_t len;
1026             $var->ptr = $var->begin = (unsigned char*)SvPVbyte($arg, len);
1027             $var->end = $var->begin + len;
1028             }
1029              
1030             T_ASN1_STRING
1031             $var = ASN1_STRING_from_SV(V_${ \($type =~ s/ ^ (?:const\s+)? (\w+) \s* \* $ /$1/xr) }, $arg);
1032             T_ASN1_INTEGER
1033             $var = ASN1_INTEGER_from_SV($arg);
1034             T_ASN1_TIME
1035             $var = ASN1_TIME_set(NULL, SvIV($arg));
1036             T_ASN1_GENERALIZEDTIME
1037             $var = ASN1_GENERALIZEDTIME_set(NULL, SvIV($arg));
1038              
1039             T_STACK
1040             STACK_FROM_ARRAY(${ \( $type =~ s/ STACK_OF \( (\w+) \) \s* \* /$1/xr) }, $var, $arg);
1041              
1042             OUTPUT
1043             T_OSSL_PARAMS
1044             {
1045             HV* hash = newHV();
1046             for (OSSL_PARAM* current = $var; current->key; ++current) {
1047             SV* value = make_param_scalar(current);
1048             hv_store(hash, current->key, strlen(current->key), value, 0);
1049             }
1050             $arg = newRV_noinc((SV*)hash);
1051             }
1052             T_ASN1_STRING
1053             $arg = ASN1_STRING_to_SV(V_${ \($type =~ s/ ^ (?:const\s+)? (\w+) \s* \* $ /$1/xr) }, $var);
1054             T_ASN1_INTEGER
1055             $arg = ASN1_INTEGER_to_SV($var);
1056             T_ASN1_TIME
1057             {
1058             struct tm tm;
1059             ASN1_TIME_to_tm($var, &tm);
1060             $arg = newSViv(timegm(&tm));
1061             }
1062             T_ASN1_GENERALIZEDTIME
1063             {
1064             struct tm tm;
1065             ASN1_TIME_to_tm($var, &tm);
1066             $arg = newSViv(timegm(&tm));
1067             }
1068             T_TIMEVAL
1069             sv_setnv($arg, $var.tv_sec + $var.tv_usec / 1000000.0);
1070             T_SUCCESS
1071             ${"$var" eq "RETVAL" ? \"$arg = $var < 0 ? &PL_sv_undef : boolSV($var);" : \"sv_setsv($arg, $var < 0 ? &PL_sv_undef : boolSV($var));"}
1072             T_PRINT
1073             ${"$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);"}
1074             T_PV
1075             sv_setpv((SV*)$arg, (const char*)$var);
1076             END
1077              
1078             BOOT:
1079             {
1080 62           HV* stash = gv_stashpvs("Crypt::OpenSSL3::", GV_ADD | GV_ADDMULTI);
1081 62           CONSTANT2(OPENSSL_, VERSION_STRING);
1082 62           CONSTANT2(OPENSSL_, VERSION_TEXT);
1083 62           CONSTANT2(OPENSSL_, FULL_VERSION_STRING);
1084 62           CONSTANT2(OPENSSL_, CFLAGS);
1085 62           CONSTANT2(OPENSSL_, BUILT_ON);
1086 62           CONSTANT2(OPENSSL_, PLATFORM);
1087 62           CONSTANT2(OPENSSL_, DIR);
1088 62           CONSTANT2(OPENSSL_, ENGINES_DIR);
1089 62           CONSTANT2(OPENSSL_, MODULES_DIR);
1090 62           CONSTANT2(OPENSSL_, CPU_INFO);
1091 62           CONSTANT2(OPENSSL_, INFO_CONFIG_DIR);
1092 62           CONSTANT2(OPENSSL_, INFO_ENGINES_DIR);
1093 62           CONSTANT2(OPENSSL_, INFO_MODULES_DIR);
1094 62           CONSTANT2(OPENSSL_, INFO_DSO_EXTENSION);
1095 62           CONSTANT2(OPENSSL_, INFO_DIR_FILENAME_SEPARATOR);
1096 62           CONSTANT2(OPENSSL_, INFO_LIST_SEPARATOR);
1097 62           CONSTANT2(OPENSSL_, INFO_CPU_SETTINGS);
1098             #if OPENSSL_VERSION_PREREQ(3, 4)
1099             CONSTANT2(OPENSSL_, WINCTX);
1100             CONSTANT2(OPENSSL_, INFO_WINDOWS_CONTEXT);
1101             #endif
1102             }
1103              
1104             const char *OpenSSL_version(int t = OPENSSL_VERSION_STRING)
1105              
1106             unsigned long OpenSSL_version_num()
1107              
1108             MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3 PREFIX = OPENSSL_
1109              
1110             unsigned int OPENSSL_version_major()
1111              
1112             unsigned int OPENSSL_version_minor()
1113              
1114             unsigned int OPENSSL_version_patch()
1115              
1116             const char *OPENSSL_version_pre_release()
1117              
1118             const char *OPENSSL_version_build_metadata()
1119              
1120             const char *OPENSSL_info(int t)
1121              
1122             MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3 PREFIX = ERR_
1123              
1124             Crypt::OpenSSL3::Error ERR_get_error()
1125              
1126             Crypt::OpenSSL3::Error ERR_peek_error()
1127              
1128             void ERR_clear_error()
1129              
1130             MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::Error PREFIX = ERR_
1131              
1132             SV* ERR_error_string(unsigned long e, size_t length = 64)
1133             CODE:
1134 0           char* ptr = (char*)make_buffer(&RETVAL, length);
1135 0           ERR_error_string_n(e, ptr, length);
1136 0           set_buffer_length(RETVAL, strlen(ptr));
1137             OUTPUT: RETVAL
1138              
1139             MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::BIO PREFIX = BIO_
1140              
1141             Crypt::OpenSSL3::BIO BIO_new_file(classname, const char *filename, const char *mode)
1142             C_ARGS: filename, mode
1143              
1144             Crypt::OpenSSL3::BIO BIO_new_fd(class, int fd, bool close_flag = FALSE)
1145             INTERFACE: BIO_new_fd BIO_new_socket BIO_new_dgram
1146             C_ARGS: fd, close_flag
1147              
1148             NO_OUTPUT int BIO_new_bio_pair(classname, OUTLIST Crypt::OpenSSL3::BIO bio1, size_t writebuf1, OUTLIST Crypt::OpenSSL3::BIO bio2, size_t writebuf2);
1149             C_ARGS: &bio1, writebuf1, &bio2, writebuf2
1150             POSTCALL:
1151 1 50         if (!RETVAL)
1152 0           XSRETURN_EMPTY;
1153              
1154             Crypt::OpenSSL3::BIO BIO_new_mem(class)
1155             C_ARGS:
1156              
1157             bool BIO_reset(Crypt::OpenSSL3::BIO b)
1158              
1159             int BIO_seek(Crypt::OpenSSL3::BIO b, int ofs)
1160              
1161             int BIO_tell(Crypt::OpenSSL3::BIO b)
1162              
1163             bool BIO_flush(Crypt::OpenSSL3::BIO b)
1164              
1165             bool BIO_eof(Crypt::OpenSSL3::BIO b)
1166              
1167             bool BIO_set_close(Crypt::OpenSSL3::BIO b, bool flag)
1168              
1169             bool BIO_get_close(Crypt::OpenSSL3::BIO b)
1170              
1171             int BIO_pending(Crypt::OpenSSL3::BIO b)
1172              
1173             int BIO_wpending(Crypt::OpenSSL3::BIO b)
1174              
1175             size_t BIO_ctrl_pending(Crypt::OpenSSL3::BIO b)
1176              
1177             size_t BIO_ctrl_wpending(Crypt::OpenSSL3::BIO b)
1178              
1179             NO_OUTPUT int BIO_read(Crypt::OpenSSL3::BIO b, OUTLIST SV* out, int size)
1180             INTERFACE: BIO_read BIO_gets BIO_get_line
1181             INIT:
1182 0           unsigned char* ptr = make_buffer(&out, size);
1183             C_ARGS: b, ptr, size
1184             POSTCALL:
1185 0 0         if (RETVAL >= 0)
1186 0           set_buffer_length(out, RETVAL);
1187              
1188             int BIO_write(Crypt::OpenSSL3::BIO b, const char *data, int length(data))
1189              
1190             bool BIO_get_ktls_send(Crypt::OpenSSL3::BIO b)
1191              
1192             bool BIO_get_ktls_recv(Crypt::OpenSSL3::BIO b)
1193              
1194             #if OPENSSL_VERSION_PREREQ(3, 2)
1195             bool BIO_get_rpoll_descriptor(Crypt::OpenSSL3::BIO b, Crypt::OpenSSL3::BIO::PollDescriptor desc)
1196              
1197             bool BIO_get_wpoll_descriptor(Crypt::OpenSSL3::BIO b, Crypt::OpenSSL3::BIO::PollDescriptor desc)
1198             #endif
1199              
1200              
1201             MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::BIO::Address PREFIX = BIO_ADDR_
1202              
1203             #if OPENSSL_VERSION_PREREQ(3, 2)
1204              
1205             Crypt::OpenSSL3::BIO::Address BIO_ADDR_new()
1206              
1207             bool BIO_ADDR_copy(Crypt::OpenSSL3::BIO::Address dst, Crypt::OpenSSL3::BIO::Address src)
1208              
1209             Crypt::OpenSSL3::BIO::Address BIO_ADDR_dup(Crypt::OpenSSL3::BIO::Address ap)
1210              
1211             void BIO_ADDR_clear(Crypt::OpenSSL3::BIO::Address ap)
1212              
1213             bool BIO_ADDR_rawmake(Crypt::OpenSSL3::BIO::Address ap, int family, const char *where, size_t length(where), unsigned short port)
1214              
1215             int BIO_ADDR_family(Crypt::OpenSSL3::BIO::Address ap)
1216              
1217             SV* BIO_ADDR_rawaddress(Crypt::OpenSSL3::BIO::Address ap)
1218             CODE:
1219             size_t length = 0;
1220             if (BIO_ADDR_rawaddress(ap, NULL, &length)) {
1221             unsigned char* ptr = make_buffer(&RETVAL, length);
1222             if (BIO_ADDR_rawaddress(ap, ptr, &length))
1223             set_buffer_length(RETVAL, length);
1224             } else
1225             RETVAL = &PL_sv_undef;
1226             OUTPUT: RETVAL
1227              
1228             unsigned short BIO_ADDR_rawport(Crypt::OpenSSL3::BIO::Address ap)
1229              
1230             char *BIO_ADDR_hostname_string(Crypt::OpenSSL3::BIO::Address ap, int numeric)
1231             INTERFACE:
1232             BIO_ADDR_hostname_string BIO_ADDR_service_string BIO_ADDR_path_string
1233             CLEANUP:
1234             OPENSSL_free(RETVAL);
1235              
1236             #endif
1237              
1238             MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::BIO::PollDescriptor PREFIX = BIO_POLL_DESCRIPTOR_
1239             BOOT:
1240             {
1241             #if OPENSSL_VERSION_PREREQ(3, 2)
1242             HV* stash = gv_stashpvs("Crypt::OpenSSL3::BIO::PollDescriptor", GV_ADD | GV_ADDMULTI);
1243             CONSTANT2(BIO_POLL_DESCRIPTOR_, TYPE_NONE);
1244             CONSTANT2(BIO_POLL_DESCRIPTOR_, TYPE_SOCK_FD);
1245             CONSTANT2(BIO_POLL_DESCRIPTOR_, CUSTOM_START);
1246             #endif
1247             }
1248              
1249             #if OPENSSL_VERSION_PREREQ(3, 2)
1250             Crypt::OpenSSL3::BIO::PollDescriptor BIO_POLL_DESCRIPTOR_new(class)
1251              
1252             int BIO_POLL_DESCRIPTOR_type(Crypt::OpenSSL3::BIO::PollDescriptor desc)
1253              
1254             int BIO_POLL_DESCRIPTOR_fd(Crypt::OpenSSL3::BIO::PollDescriptor desc)
1255             #endif
1256              
1257              
1258             MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::PEM PREFIX = PEM_
1259              
1260             int PEM_write(Crypt::OpenSSL3::BIO bp, const char *name, const char *header, const unsigned char *data, long length(data))
1261              
1262             NO_OUTPUT int PEM_read(Crypt::OpenSSL3::BIO bp, OUTLIST char *name, OUTLIST char *header, OUTLIST SV* data)
1263             unsigned char* ptr;
1264             long len;
1265             C_ARGS: bp, &name, &header, &ptr, &len
1266             POSTCALL:
1267 0 0         if (RETVAL)
1268 0           data = newSVpvn(ptr, len);
1269             else
1270 0           XSRETURN_EMPTY;
1271             CLEANUP:
1272 0           OPENSSL_free(name);
1273 0           OPENSSL_free(header);
1274 0           OPENSSL_free(ptr);
1275              
1276              
1277             MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::BigNum PREFIX = BN_
1278              
1279             BOOT:
1280             {
1281 62           HV* stash = gv_stashpvs("Crypt::OpenSSL3::BigNum", GV_ADD | GV_ADDMULTI);
1282 62           CONSTANT2(BN_, RAND_TOP_ANY);
1283 62           CONSTANT2(BN_, RAND_TOP_ONE);
1284 62           CONSTANT2(BN_, RAND_TOP_TWO);
1285              
1286 62           CONSTANT2(BN_, RAND_BOTTOM_ANY);
1287 62           CONSTANT2(BN_, RAND_BOTTOM_ODD);
1288             }
1289              
1290              
1291             Crypt::OpenSSL3::BigNum BN_new(classname)
1292             INTERFACE: BN_new BN_secure_new
1293             C_ARGS:
1294              
1295             Crypt::OpenSSL3::BigNum BN_dup(Crypt::OpenSSL3::BigNum self)
1296              
1297             bool BN_copy(Crypt::OpenSSL3::BigNum self, Crypt::OpenSSL3::BigNum other)
1298              
1299             void BN_clear(Crypt::OpenSSL3::BigNum a)
1300              
1301             bool BN_add(Crypt::OpenSSL3::BigNum r, Crypt::OpenSSL3::BigNum a, Crypt::OpenSSL3::BigNum b)
1302              
1303             bool BN_sub(Crypt::OpenSSL3::BigNum r, Crypt::OpenSSL3::BigNum a, Crypt::OpenSSL3::BigNum b)
1304              
1305             bool BN_mul(Crypt::OpenSSL3::BigNum r, Crypt::OpenSSL3::BigNum a, Crypt::OpenSSL3::BigNum b, Crypt::OpenSSL3::BigNum::Context ctx)
1306              
1307             bool BN_sqr(Crypt::OpenSSL3::BigNum r, Crypt::OpenSSL3::BigNum a, Crypt::OpenSSL3::BigNum::Context ctx)
1308              
1309             bool BN_div(Crypt::OpenSSL3::BigNum dv, Crypt::OpenSSL3::BigNum rem, Crypt::OpenSSL3::BigNum a, Crypt::OpenSSL3::BigNum d, Crypt::OpenSSL3::BigNum::Context ctx)
1310              
1311             bool BN_mod(Crypt::OpenSSL3::BigNum rem, Crypt::OpenSSL3::BigNum a, Crypt::OpenSSL3::BigNum m, Crypt::OpenSSL3::BigNum::Context ctx)
1312              
1313             bool BN_nnmod(Crypt::OpenSSL3::BigNum r, Crypt::OpenSSL3::BigNum a, Crypt::OpenSSL3::BigNum m, Crypt::OpenSSL3::BigNum::Context ctx)
1314              
1315             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)
1316              
1317             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)
1318              
1319             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)
1320              
1321             bool BN_mod_sqr(Crypt::OpenSSL3::BigNum r, Crypt::OpenSSL3::BigNum a, Crypt::OpenSSL3::BigNum m, Crypt::OpenSSL3::BigNum::Context ctx)
1322              
1323             bool BN_mod_sqrt(Crypt::OpenSSL3::BigNum in, Crypt::OpenSSL3::BigNum a, Crypt::OpenSSL3::BigNum p, Crypt::OpenSSL3::BigNum::Context ctx)
1324              
1325             bool BN_exp(Crypt::OpenSSL3::BigNum r, Crypt::OpenSSL3::BigNum a, Crypt::OpenSSL3::BigNum p, Crypt::OpenSSL3::BigNum::Context ctx)
1326              
1327             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)
1328              
1329             bool BN_gcd(Crypt::OpenSSL3::BigNum r, Crypt::OpenSSL3::BigNum a, Crypt::OpenSSL3::BigNum b, Crypt::OpenSSL3::BigNum::Context ctx)
1330              
1331             int BN_num_bytes(Crypt::OpenSSL3::BigNum a)
1332              
1333             int BN_num_bits(Crypt::OpenSSL3::BigNum a)
1334              
1335             NO_OUTPUT int BN_bn2bin(Crypt::OpenSSL3::BigNum a, OUTLIST SV* out)
1336             INIT:
1337 0           unsigned char* ptr = make_buffer(&out, BN_num_bytes(a));
1338             C_ARGS: a, ptr
1339             POSTCALL:
1340 0           set_buffer_length(out, RETVAL);
1341              
1342             NO_OUTPUT int BN_bn2binpad(Crypt::OpenSSL3::BigNum a, OUTLIST SV* out, int tolen = BN_num_bytes(a))
1343             INTERFACE: BN_bn2binpad BN_bn2lebinpad BN_bn2nativepad
1344             INIT:
1345 0           unsigned char* ptr = make_buffer(&out, tolen);
1346             C_ARGS: a, ptr, tolen
1347             POSTCALL:
1348 0 0         if (RETVAL >= 0)
1349 0           set_buffer_length(out, RETVAL);
1350              
1351             Crypt::OpenSSL3::BigNum BN_bin2bn(const unsigned char *s, int length(s))
1352             INTERFACE: BN_bin2bn BN_lebin2bn BN_native2bn
1353             C_ARGS: s, XSauto_length_of_s, NULL
1354              
1355             NO_OUTPUT int BN_bn2lebinpad(Crypt::OpenSSL3::BigNum a, OUTLIST SV* out, int tolen)
1356             INTERFACE: BN_bn2lebinpad BN_bn2nativepad
1357             INIT:
1358 0           unsigned char* ptr = make_buffer(&out, tolen);
1359             C_ARGS: a, ptr, tolen
1360             POSTCALL:
1361 0 0         if (RETVAL >= 0)
1362 0           set_buffer_length(out, RETVAL);
1363              
1364             #if OPENSSL_VERSION_PREREQ(3, 2)
1365             NO_OUTPUT int BN_signed_bn2lebin(Crypt::OpenSSL3::BigNum a, OUTLIST SV* out, int tolen = BN_num_bytes(a))
1366             INTERFACE: BN_signed_bn2bin BN_signed_bn2lebin BN_signed_bn2native
1367             INIT:
1368             unsigned char* ptr = make_buffer(&out, tolen);
1369             C_ARGS: a, ptr, tolen
1370             POSTCALL:
1371             if (RETVAL >= 0)
1372             set_buffer_length(out, RETVAL);
1373              
1374             Crypt::OpenSSL3::BigNum BN_signed_bin2bn(const unsigned char *s, int length(s))
1375             INTERFACE: BN_signed_bin2bn BN_signed_lebin2bn BN_signed_native2bn
1376             C_ARGS: s, XSauto_length_of_s, NULL
1377              
1378             #endif
1379              
1380             char *BN_bn2hex(Crypt::OpenSSL3::BigNum a)
1381             INTERFACE: BN_bn2hex BN_bn2dec
1382             CLEANUP:
1383 0           OPENSSL_free(RETVAL);
1384              
1385             NO_OUTPUT int BN_hex2bn(OUTLIST Crypt::OpenSSL3::BigNum a, const char *str)
1386             INIT:
1387 0           a = NULL;
1388             INTERFACE: BN_hex2bn BN_dec2bn
1389             C_ARGS: &a, str
1390             POSTCALL:
1391 0 0         if (!RETVAL)
1392 0           XSRETURN_UNDEF;
1393              
1394             bool BN_print(Crypt::OpenSSL3::BigNum a, Crypt::OpenSSL3::BIO fp)
1395             C_ARGS: fp, a
1396              
1397              
1398             NO_OUTPUT int BN_bn2mpi(Crypt::OpenSSL3::BigNum a, OUTLIST SV* out)
1399             INIT:
1400 0           unsigned char* ptr = make_buffer(&out, BN_bn2mpi(a, NULL));
1401             C_ARGS: a, ptr
1402             POSTCALL:
1403 0           set_buffer_length(out, RETVAL);
1404              
1405             Crypt::OpenSSL3::BigNum BN_mpi2bn(unsigned char *s, int len)
1406             C_ARGS: s, len, NULL
1407              
1408             bool BN_check_prime(Crypt::OpenSSL3::BigNum p, Crypt::OpenSSL3::BigNum::Context ctx)
1409             C_ARGS: p, ctx, NULL
1410              
1411             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)
1412             C_ARGS: ret, bits, safe, add, rem, NULL, ctx
1413              
1414             bool BN_set_word(Crypt::OpenSSL3::BigNum a, UV w)
1415              
1416             UV BN_get_word(Crypt::OpenSSL3::BigNum a)
1417              
1418             bool BN_add_word(Crypt::OpenSSL3::BigNum a, UV w)
1419              
1420             bool BN_sub_word(Crypt::OpenSSL3::BigNum a, UV w)
1421              
1422             bool BN_mul_word(Crypt::OpenSSL3::BigNum a, UV w)
1423              
1424             UV BN_div_word(Crypt::OpenSSL3::BigNum a, UV w)
1425              
1426             UV BN_mod_word(Crypt::OpenSSL3::BigNum a, UV w)
1427              
1428             int BN_cmp(Crypt::OpenSSL3::BigNum a, Crypt::OpenSSL3::BigNum b)
1429              
1430             int BN_ucmp(Crypt::OpenSSL3::BigNum a, Crypt::OpenSSL3::BigNum b)
1431              
1432             bool BN_is_zero(Crypt::OpenSSL3::BigNum a)
1433              
1434             bool BN_is_one(Crypt::OpenSSL3::BigNum a)
1435              
1436             bool BN_is_word(Crypt::OpenSSL3::BigNum a, UV w)
1437              
1438             bool BN_abs_is_word(Crypt::OpenSSL3::BigNum a, UV w)
1439              
1440             bool BN_is_odd(Crypt::OpenSSL3::BigNum a)
1441              
1442             #if OPENSSL_VERSION_PREREQ(3, 2)
1443             bool BN_are_coprime(Crypt::OpenSSL3::BigNum a, Crypt::OpenSSL3::BigNum b, Crypt::OpenSSL3::BigNum::Context ctx);
1444             #endif
1445              
1446             bool BN_clear_bit(Crypt::OpenSSL3::BigNum a, int n)
1447              
1448             bool BN_is_bit_set(Crypt::OpenSSL3::BigNum a, int n)
1449              
1450             bool BN_mask_bits(Crypt::OpenSSL3::BigNum a, int n)
1451              
1452             bool BN_lshift(Crypt::OpenSSL3::BigNum r, Crypt::OpenSSL3::BigNum a, int n)
1453              
1454             bool BN_lshift1(Crypt::OpenSSL3::BigNum r, Crypt::OpenSSL3::BigNum a)
1455              
1456             bool BN_rshift(Crypt::OpenSSL3::BigNum r, Crypt::OpenSSL3::BigNum a, int n)
1457              
1458             bool BN_rshift1(Crypt::OpenSSL3::BigNum r, Crypt::OpenSSL3::BigNum a)
1459              
1460             bool BN_rand_ex(Crypt::OpenSSL3::BigNum rnd, int bits, int top, int bottom, unsigned int strength, Crypt::OpenSSL3::BigNum::Context ctx)
1461              
1462             bool BN_rand(Crypt::OpenSSL3::BigNum rnd, int bits, int top, int bottom)
1463              
1464              
1465             MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::BigNum::Context PREFIX = BN_CTX_
1466              
1467             Crypt::OpenSSL3::BigNum::Context BN_CTX_new(classname)
1468             INTERFACE: BN_CTX_new BN_CTX_secure_new
1469             C_ARGS:
1470              
1471              
1472             MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::ASN
1473              
1474             BOOT:
1475             {
1476 62           HV* stash = gv_stashpvs("Crypt::OpenSSL3::ASN1", GV_ADD | GV_ADDMULTI);
1477 62           CONSTANT2(V_ASN1_, EOC);
1478 62           CONSTANT2(V_ASN1_, BOOLEAN);
1479 62           CONSTANT2(V_ASN1_, INTEGER);
1480 62           CONSTANT2(V_ASN1_, BIT_STRING);
1481 62           CONSTANT2(V_ASN1_, OCTET_STRING);
1482 62           CONSTANT2(V_ASN1_, NULL);
1483 62           CONSTANT2(V_ASN1_, OBJECT);
1484 62           CONSTANT2(V_ASN1_, OBJECT_DESCRIPTOR);
1485 62           CONSTANT2(V_ASN1_, EXTERNAL);
1486 62           CONSTANT2(V_ASN1_, REAL);
1487 62           CONSTANT2(V_ASN1_, ENUMERATED);
1488 62           CONSTANT2(V_ASN1_, UTF8STRING);
1489 62           CONSTANT2(V_ASN1_, SEQUENCE);
1490 62           CONSTANT2(V_ASN1_, SET);
1491 62           CONSTANT2(V_ASN1_, NUMERICSTRING);
1492 62           CONSTANT2(V_ASN1_, PRINTABLESTRING);
1493 62           CONSTANT2(V_ASN1_, T61STRING);
1494 62           CONSTANT2(V_ASN1_, TELETEXSTRING);
1495 62           CONSTANT2(V_ASN1_, VIDEOTEXSTRING);
1496 62           CONSTANT2(V_ASN1_, IA5STRING);
1497 62           CONSTANT2(V_ASN1_, UTCTIME);
1498 62           CONSTANT2(V_ASN1_, GENERALIZEDTIME);
1499 62           CONSTANT2(V_ASN1_, GRAPHICSTRING);
1500 62           CONSTANT2(V_ASN1_, ISO64STRING);
1501 62           CONSTANT2(V_ASN1_, VISIBLESTRING);
1502 62           CONSTANT2(V_ASN1_, GENERALSTRING);
1503 62           CONSTANT2(V_ASN1_, UNIVERSALSTRING);
1504 62           CONSTANT2(V_ASN1_, BMPSTRING);
1505             }
1506              
1507              
1508             MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::ASN1::Decoder PREFIX = ASN1_DECODER_
1509              
1510             SV* ASN1_DECODER_new(class, SV* input)
1511             C_ARGS: input
1512              
1513             size_t ASN1_DECODER_get_bytes_left(Crypt::OpenSSL3::ASN1::Decoder buffer)
1514              
1515              
1516             MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::ASN1::Value PREFIX = ASN1_TYPE_
1517              
1518             int ASN1_TYPE_get_type(Crypt::OpenSSL3::ASN1::Value a)
1519              
1520             SV* ASN1_TYPE_get_value(Crypt::OpenSSL3::ASN1::Value a)
1521              
1522             bool ASN1_TYPE_set(Crypt::OpenSSL3::ASN1::Value a, int type, SV* value)
1523             CODE:
1524             void* converted;
1525 0 0         if (type == V_ASN1_NULL)
1526 0           converted = NULL;
1527 0 0         else if (type == V_ASN1_BOOLEAN)
1528 0 0         converted = SvTRUE(value) ? (void*)0xff : 0;
1529 0 0         else if (type == V_ASN1_OBJECT)
1530 0           converted = ASN1_OBJECT_dup(get_ASN1_OBJECT(aTHX_ value));
1531 0 0         else if (type == V_ASN1_INTEGER || type == V_ASN1_ENUMERATED)
    0          
1532 0           converted = ASN1_INTEGER_from_SV(value);
1533             else
1534 0           converted = ASN1_STRING_from_SV(type, value);
1535              
1536 0 0         RETVAL = converted || type == V_ASN1_NULL || type == V_ASN1_BOOLEAN;
    0          
    0          
1537 0 0         if (RETVAL)
1538 0           ASN1_TYPE_set(a, type, converted);
1539             OUTPUT: RETVAL
1540              
1541             Crypt::OpenSSL3::ASN1::Value ASN1_TYPE_decode_der(class, ASN1_DECODER* buffer)
1542             CODE:
1543 0           RETVAL = d2i_ASN1_TYPE(NULL, &buffer->ptr, buffer->end - buffer->ptr);
1544 0 0         if (!RETVAL)
1545 0           XSRETURN_UNDEF;
1546             OUTPUT: RETVAL
1547              
1548             SV* ASN1_TYPE_encode_der(Crypt::OpenSSL3::ASN1::Value x)
1549             CODE:
1550 0           int length = i2d_ASN1_TYPE(x, NULL);
1551 0 0         if (length > 0) {
1552 0           unsigned char* ptr = make_buffer(&RETVAL, length);
1553 0           i2d_ASN1_TYPE(x, &ptr);
1554 0           set_buffer_length(RETVAL, length);
1555             } else
1556 0           RETVAL = &PL_sv_undef;
1557             OUTPUT: RETVAL
1558              
1559              
1560             MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::ASN1::Object PREFIX = OBJ_
1561              
1562             Crypt::OpenSSL3::ASN1::Object OBJ_from_text(class, const char *s, bool no_name = FALSE)
1563             C_ARGS: s, no_name
1564              
1565             Crypt::OpenSSL3::ASN1::Object OBJ_from_nid(class, Crypt::OpenSSL3::NID n)
1566             C_ARGS: n
1567              
1568             int OBJ_cmp(Crypt::OpenSSL3::ASN1::Object a, Crypt::OpenSSL3::ASN1::Object b)
1569              
1570             Crypt::OpenSSL3::NID OBJ_to_nid(Crypt::OpenSSL3::ASN1::Object o)
1571              
1572             size_t OBJ_length(Crypt::OpenSSL3::ASN1::Object obj)
1573              
1574             const unsigned char *OBJ_get_data(Crypt::OpenSSL3::ASN1::Object obj)
1575              
1576             SV* OBJ_to_text(Crypt::OpenSSL3::ASN1::Object a, bool no_name = FALSE)
1577              
1578             Crypt::OpenSSL3::ASN1::Object OBJ_decode_der(class, ASN1_DECODER* buffer)
1579             CODE:
1580 0           RETVAL = d2i_ASN1_OBJECT(NULL, &buffer->ptr, buffer->end - buffer->ptr);
1581 0 0         if (!RETVAL)
1582 0           XSRETURN_UNDEF;
1583             OUTPUT: RETVAL
1584              
1585             SV* OBJ_encode_der(Crypt::OpenSSL3::ASN1::Object x)
1586             CODE:
1587 0           int length = i2d_ASN1_OBJECT(x, NULL);
1588 0 0         if (length > 0) {
1589 0           unsigned char* ptr = make_buffer(&RETVAL, length);
1590 0           i2d_ASN1_OBJECT(x, &ptr);
1591 0           set_buffer_length(RETVAL, length);
1592             } else
1593 0           RETVAL = &PL_sv_undef;
1594             OUTPUT: RETVAL
1595              
1596              
1597             MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::X509 PREFIX = X509_
1598              
1599             BOOT:
1600             {
1601 62           HV* stash = gv_stashpvs("Crypt::OpenSSL3::X509", GV_ADD | GV_ADDMULTI);
1602 62           CONSTANT2(X509_, CHECK_FLAG_ALWAYS_CHECK_SUBJECT);
1603 62           CONSTANT2(X509_, CHECK_FLAG_NEVER_CHECK_SUBJECT);
1604 62           CONSTANT2(X509_, CHECK_FLAG_NO_WILDCARDS);
1605 62           CONSTANT2(X509_, CHECK_FLAG_NO_PARTIAL_WILDCARDS);
1606 62           CONSTANT2(X509_, CHECK_FLAG_MULTI_LABEL_WILDCARDS);
1607 62           CONSTANT2(X509_, CHECK_FLAG_SINGLE_LABEL_SUBDOMAINS);
1608             }
1609              
1610             Crypt::OpenSSL3::X509 X509_new(class)
1611             C_ARGS:
1612              
1613             Crypt::OpenSSL3::X509 X509_dup(Crypt::OpenSSL3::X509 self)
1614              
1615             Crypt::OpenSSL3::X509 X509_read_pem(class, Crypt::OpenSSL3::BIO bio)
1616             C_ARGS: bio, NULL, NULL, NULL
1617             POSTCALL:
1618 0 0         if (!RETVAL)
1619 0           XSRETURN_UNDEF;
1620              
1621             bool X509_write_pem(Crypt::OpenSSL3::X509 x, Crypt::OpenSSL3::BIO bio)
1622             C_ARGS: bio, x
1623              
1624             Crypt::OpenSSL3::X509 X509_read_der(class, Crypt::OpenSSL3::BIO bio)
1625             C_ARGS: bio, NULL
1626             POSTCALL:
1627 0 0         if (!RETVAL)
1628 0           XSRETURN_UNDEF;
1629              
1630             bool X509_write_der(Crypt::OpenSSL3::X509 x, Crypt::OpenSSL3::BIO bio)
1631             C_ARGS: bio, x
1632              
1633             Crypt::OpenSSL3::X509 X509_decode_der(class, ASN1_DECODER* buffer)
1634             CODE:
1635 0           RETVAL = d2i_X509(NULL, &buffer->ptr, buffer->end - buffer->ptr);
1636 0 0         if (!RETVAL)
1637 0           XSRETURN_UNDEF;
1638             OUTPUT: RETVAL
1639              
1640             SV* X509_encode_der(Crypt::OpenSSL3::X509 x)
1641             CODE:
1642 0           int length = i2d_X509(x, NULL);
1643 0 0         if (length > 0) {
1644 0           unsigned char* ptr = make_buffer(&RETVAL, length);
1645 0           i2d_X509(x, &ptr);
1646 0           set_buffer_length(RETVAL, length);
1647             } else
1648 0           RETVAL = &PL_sv_undef;
1649             OUTPUT: RETVAL
1650              
1651             SV* X509_encode_der_tbs(Crypt::OpenSSL3::X509 x)
1652             CODE:
1653 0           int length = i2d_re_X509_tbs(x, NULL);
1654 0 0         if (length > 0) {
1655 0           unsigned char* ptr = make_buffer(&RETVAL, length);
1656 0           i2d_re_X509_tbs(x, &ptr);
1657 0           set_buffer_length(RETVAL, length);
1658             } else
1659 0           RETVAL = &PL_sv_undef;
1660             OUTPUT: RETVAL
1661              
1662             const char *X509_get_default_cert_file(class)
1663             C_ARGS:
1664              
1665             const char *X509_get_default_cert_dir(class)
1666             C_ARGS:
1667              
1668             const char *X509_get_default_cert_file_env(class)
1669             C_ARGS:
1670              
1671             const char *X509_get_default_cert_dir_env(class)
1672             C_ARGS:
1673              
1674             bool X509_sign(Crypt::OpenSSL3::X509 x, Crypt::OpenSSL3::PKey pkey, Crypt::OpenSSL3::MD md)
1675              
1676             bool X509_sign_ctx(Crypt::OpenSSL3::X509 x, Crypt::OpenSSL3::MD::Context ctx)
1677              
1678             bool X509_verify(Crypt::OpenSSL3::X509 x, Crypt::OpenSSL3::PKey pkey)
1679              
1680             bool X509_self_signed(Crypt::OpenSSL3::X509 cert, bool verify_signature)
1681              
1682             Crypt::OpenSSL3::PKey X509_get_pubkey(Crypt::OpenSSL3::X509 x)
1683              
1684             bool X509_set_pubkey(Crypt::OpenSSL3::X509 x, Crypt::OpenSSL3::PKey pkey);
1685              
1686             long X509_get_version(Crypt::OpenSSL3::X509 x)
1687              
1688             bool X509_set_version(Crypt::OpenSSL3::X509 x, long version)
1689              
1690             void X509_get_signature(Crypt::OpenSSL3::X509 x, OUTLIST const ASN1_BIT_STRING* psig, OUTLIST Crypt::OpenSSL3::X509::Algorithm palg)
1691             C_ARGS: &psig, (const X509_ALGOR**)&palg, x
1692             POSTCALL:
1693 0           palg = X509_ALGOR_dup(palg);
1694              
1695             Crypt::OpenSSL3::NID X509_get_signature_nid(Crypt::OpenSSL3::X509 x)
1696              
1697             Crypt::OpenSSL3::X509::Algorithm X509_get_tbs_sigalg(Crypt::OpenSSL3::X509 x)
1698             POSTCALL:
1699 0           RETVAL = X509_ALGOR_dup(RETVAL);
1700              
1701             ASN1_TIME* X509_get_notBefore(Crypt::OpenSSL3::X509 x)
1702             INTERFACE: X509_get_notBefore X509_get_notAfter
1703             POSTCALL:
1704 0           RETVAL = ASN1_TIME_dup(RETVAL);
1705              
1706             bool X509_set_notBefore(Crypt::OpenSSL3::X509 x, ASN1_TIME* tm)
1707             INTERFACE: X509_set_notBefore X509_set_notAfter
1708             POSTCALL:
1709 0           ASN1_TIME_free(tm);
1710              
1711             Crypt::OpenSSL3::X509::Name X509_get_subject_name(Crypt::OpenSSL3::X509 x)
1712             INTERFACE:
1713             X509_get_subject_name X509_get_issuer_name
1714             POSTCALL:
1715 0           RETVAL = X509_NAME_dup(RETVAL);
1716              
1717             void X509_get_subject_alt_names(Crypt::OpenSSL3::X509 x)
1718             PPCODE:
1719 0           STACK_OF(GENERAL_NAME)* gens = X509_get_ext_d2i(x, NID_subject_alt_name, NULL, NULL);
1720 0 0         STACK_TO_STACK(GENERAL_NAME, gens);
    0          
    0          
    0          
1721              
1722             void X509_get_issuer_alt_names(Crypt::OpenSSL3::X509 x)
1723             PPCODE:
1724 0           STACK_OF(GENERAL_NAME)* gens = X509_get_ext_d2i(x, NID_issuer_alt_name, NULL, NULL);
1725 0 0         STACK_TO_STACK(GENERAL_NAME, gens);
    0          
    0          
    0          
1726              
1727             bool X509_set_subject_name(Crypt::OpenSSL3::X509 x, Crypt::OpenSSL3::X509::Name name)
1728              
1729             bool X509_set_issuer_name(Crypt::OpenSSL3::X509 x, Crypt::OpenSSL3::X509::Name name)
1730              
1731             unsigned long X509_subject_name_hash(Crypt::OpenSSL3::X509 x)
1732              
1733             unsigned long X509_issuer_name_hash(Crypt::OpenSSL3::X509 x)
1734              
1735             void X509_get_ct_precert_scts(Crypt::OpenSSL3::X509 x)
1736             PPCODE:
1737 0           STACK_OF(SCT)* scts = X509_get_ext_d2i(x, NID_ct_precert_scts, NULL, NULL);
1738 0 0         STACK_TO_STACK(SCT, scts);
    0          
    0          
    0          
1739              
1740             NO_OUTPUT Bool X509_digest(Crypt::OpenSSL3::X509 data, Crypt::OpenSSL3::MD type, OUTLIST SV* digest)
1741             INTERFACE: X509_digest X509_pubkey_digest
1742             INIT:
1743 0           unsigned int output_length = EVP_MD_size(type);
1744 0           unsigned char* ptr = make_buffer(&digest, output_length);
1745             C_ARGS: data, type, ptr, &output_length
1746             POSTCALL:
1747 0 0         if (RETVAL)
1748 0           set_buffer_length(digest, output_length);
1749              
1750             ASN1_OCTET_STRING* X509_digest_sig(Crypt::OpenSSL3::X509 cert)
1751             C_ARGS: cert, NULL, NULL
1752             CLEANUP:
1753 0           ASN1_OCTET_STRING_free(RETVAL);
1754              
1755             ASN1_OCTET_STRING* X509_get_distinguishing_id(Crypt::OpenSSL3::X509 x)
1756             POSTCALL:
1757 0 0         if (!RETVAL)
1758 0           XSRETURN_UNDEF;
1759              
1760             void X509_set_distinguishing_id(Crypt::OpenSSL3::X509 x, ASN1_OCTET_STRING* distid)
1761              
1762             bool X509_check_ca(Crypt::OpenSSL3::X509 cert)
1763              
1764             bool X509_check_host(Crypt::OpenSSL3::X509 cert, const char *name, size_t length(name), unsigned int flags, OUTLIST char *peername)
1765              
1766             bool X509_check_email(Crypt::OpenSSL3::X509 cert, const char *address, size_t length(address), unsigned int flags)
1767              
1768             bool X509_check_ip(Crypt::OpenSSL3::X509 cert, const unsigned char *address, size_t length(address), unsigned int flags)
1769              
1770             bool X509_check_ip_asc(Crypt::OpenSSL3::X509 cert, const char *address, unsigned int flags)
1771              
1772             bool X509_check_issued(Crypt::OpenSSL3::X509 issuer, Crypt::OpenSSL3::X509 subject)
1773              
1774             bool X509_check_private_key(Crypt::OpenSSL3::X509 cert, Crypt::OpenSSL3::PKey pkey)
1775              
1776             int X509_cmp(Crypt::OpenSSL3::X509 a, Crypt::OpenSSL3::X509 b)
1777              
1778             int X509_issuer_and_serial_cmp(Crypt::OpenSSL3::X509 a, Crypt::OpenSSL3::X509 b)
1779              
1780             int X509_issuer_name_cmp(Crypt::OpenSSL3::X509 a, Crypt::OpenSSL3::X509 b)
1781              
1782             int X509_subject_name_cmp(Crypt::OpenSSL3::X509 a, Crypt::OpenSSL3::X509 b)
1783              
1784             long X509_get_pathlen(Crypt::OpenSSL3::X509 x)
1785              
1786             uint32_t X509_get_extension_flags(Crypt::OpenSSL3::X509 x)
1787              
1788             uint32_t X509_get_key_usage(Crypt::OpenSSL3::X509 x)
1789              
1790             uint32_t X509_get_extended_key_usage(Crypt::OpenSSL3::X509 x)
1791              
1792             const ASN1_OCTET_STRING* X509_get_subject_key_id(Crypt::OpenSSL3::X509 x)
1793             INTERFACE: X509_get_subject_key_id X509_get_authority_key_id
1794             POSTCALL:
1795 0 0         if (!RETVAL)
1796 0           XSRETURN_UNDEF;
1797              
1798             Crypt::OpenSSL3::X509::GeneralName X509_get_authority_issuer(Crypt::OpenSSL3::X509 x)
1799             PPCODE:
1800 0           const STACK_OF(GENERAL_NAME)* gns = X509_get0_authority_issuer(x);
1801 0 0         CSTACK_TO_STACK(GENERAL_NAME, gns);
    0          
    0          
    0          
1802              
1803             const ASN1_INTEGER* X509_get_authority_serial(Crypt::OpenSSL3::X509 x)
1804             POSTCALL:
1805 0 0         if (!RETVAL)
1806 0           XSRETURN_UNDEF;
1807              
1808             void X509_set_proxy_flag(Crypt::OpenSSL3::X509 x)
1809              
1810             void X509_set_proxy_pathlen(Crypt::OpenSSL3::X509 x, int l)
1811              
1812             long X509_get_proxy_pathlen(Crypt::OpenSSL3::X509 x)
1813              
1814             int X509_get_ext_count(Crypt::OpenSSL3::X509 x)
1815              
1816             void X509_get_extensions(Crypt::OpenSSL3::X509 x)
1817             PPCODE:
1818 0           const STACK_OF(X509_EXTENSION)* exts = X509_get0_extensions(x);
1819 0 0         CSTACK_TO_STACK(X509_EXTENSION, exts);
    0          
    0          
    0          
1820              
1821             Crypt::OpenSSL3::X509::Extension X509_get_ext(Crypt::OpenSSL3::X509 x, int loc)
1822             POSTCALL:
1823 0 0         if (RETVAL)
1824 0           RETVAL = X509_EXTENSION_dup(RETVAL);
1825             else
1826 0           XSRETURN_UNDEF;
1827              
1828             int X509_get_ext_by_NID(Crypt::OpenSSL3::X509 x, Crypt::OpenSSL3::NID nid, int lastpos = -1)
1829             POSTCALL:
1830 0 0         if (RETVAL == -1)
1831 0           XSRETURN_UNDEF;
1832              
1833             int X509_get_ext_by_OBJ(Crypt::OpenSSL3::X509 x, Crypt::OpenSSL3::ASN1::Object obj, int lastpos = -1)
1834             POSTCALL:
1835 0 0         if (RETVAL == -1)
1836 0           XSRETURN_UNDEF;
1837              
1838             int X509_get_ext_by_critical(Crypt::OpenSSL3::X509 x, int crit, int lastpos = -1)
1839             POSTCALL:
1840 0 0         if (RETVAL == -1)
1841 0           XSRETURN_UNDEF;
1842              
1843             Crypt::OpenSSL3::X509::Extension X509_delete_ext(Crypt::OpenSSL3::X509 x, int loc)
1844              
1845             int X509_add_ext(Crypt::OpenSSL3::X509 x, Crypt::OpenSSL3::X509::Extension ex, int loc = -1)
1846              
1847             ASN1_INTEGER* X509_get_serialNumber(Crypt::OpenSSL3::X509 x)
1848              
1849             bool X509_set_serialNumber(Crypt::OpenSSL3::X509 x, ASN1_INTEGER* serial)
1850             POSTCALL:
1851 0           ASN1_INTEGER_free(serial);
1852              
1853              
1854             MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::X509::VerifyParam PREFIX = X509_VERIFY_PARAM_
1855              
1856             BOOT:
1857             {
1858 62           HV* stash = gv_stashpvs("Crypt::OpenSSL3::X509::VerifyParam", GV_ADD | GV_ADDMULTI);
1859              
1860 62           CONSTANT2(X509_, PURPOSE_SSL_CLIENT);
1861 62           CONSTANT2(X509_, PURPOSE_SSL_SERVER);
1862 62           CONSTANT2(X509_, PURPOSE_NS_SSL_SERVER);
1863 62           CONSTANT2(X509_, PURPOSE_SMIME_SIGN);
1864 62           CONSTANT2(X509_, PURPOSE_SMIME_ENCRYPT);
1865 62           CONSTANT2(X509_, PURPOSE_CRL_SIGN);
1866 62           CONSTANT2(X509_, PURPOSE_ANY);
1867 62           CONSTANT2(X509_, PURPOSE_OCSP_HELPER);
1868 62           CONSTANT2(X509_, PURPOSE_TIMESTAMP_SIGN);
1869             #if OPENSSL_VERSION_PREREQ(3, 1)
1870             CONSTANT2(X509_, PURPOSE_CODE_SIGN);
1871             #endif
1872              
1873 62           CONSTANT2(X509_, V_FLAG_USE_CHECK_TIME);
1874 62           CONSTANT2(X509_, V_FLAG_CRL_CHECK);
1875 62           CONSTANT2(X509_, V_FLAG_CRL_CHECK_ALL);
1876 62           CONSTANT2(X509_, V_FLAG_IGNORE_CRITICAL);
1877 62           CONSTANT2(X509_, V_FLAG_X509_STRICT);
1878 62           CONSTANT2(X509_, V_FLAG_ALLOW_PROXY_CERTS);
1879 62           CONSTANT2(X509_, V_FLAG_POLICY_CHECK);
1880 62           CONSTANT2(X509_, V_FLAG_EXPLICIT_POLICY);
1881 62           CONSTANT2(X509_, V_FLAG_INHIBIT_ANY);
1882 62           CONSTANT2(X509_, V_FLAG_INHIBIT_MAP);
1883 62           CONSTANT2(X509_, V_FLAG_NOTIFY_POLICY);
1884 62           CONSTANT2(X509_, V_FLAG_EXTENDED_CRL_SUPPORT);
1885 62           CONSTANT2(X509_, V_FLAG_USE_DELTAS);
1886 62           CONSTANT2(X509_, V_FLAG_CHECK_SS_SIGNATURE);
1887 62           CONSTANT2(X509_, V_FLAG_TRUSTED_FIRST);
1888 62           CONSTANT2(X509_, V_FLAG_SUITEB_128_LOS_ONLY);
1889 62           CONSTANT2(X509_, V_FLAG_SUITEB_192_LOS);
1890 62           CONSTANT2(X509_, V_FLAG_SUITEB_128_LOS);
1891 62           CONSTANT2(X509_, V_FLAG_PARTIAL_CHAIN);
1892 62           CONSTANT2(X509_, V_FLAG_NO_ALT_CHAINS);
1893 62           CONSTANT2(X509_, V_FLAG_NO_CHECK_TIME);
1894             #if OPENSSL_VERSION_PREREQ(3, 4)
1895             CONSTANT2(X509_, V_FLAG_OCSP_RESP_CHECK);
1896             CONSTANT2(X509_, V_FLAG_OCSP_RESP_CHECK_ALL);
1897             #endif
1898             }
1899              
1900             Crypt::OpenSSL3::X509::VerifyParam X509_VERIFY_PARAM_new(class)
1901             C_ARGS:
1902              
1903             bool X509_VERIFY_PARAM_set_flags(Crypt::OpenSSL3::X509::VerifyParam param, unsigned long flags)
1904              
1905             bool X509_VERIFY_PARAM_clear_flags(Crypt::OpenSSL3::X509::VerifyParam param, unsigned long flags)
1906              
1907             unsigned long X509_VERIFY_PARAM_get_flags(Crypt::OpenSSL3::X509::VerifyParam param)
1908              
1909             bool X509_VERIFY_PARAM_set_inh_flags(Crypt::OpenSSL3::X509::VerifyParam param, uint32_t flags)
1910              
1911             uint32_t X509_VERIFY_PARAM_get_inh_flags(Crypt::OpenSSL3::X509::VerifyParam param)
1912              
1913             bool X509_VERIFY_PARAM_set_purpose(Crypt::OpenSSL3::X509::VerifyParam param, int purpose)
1914              
1915             #if OPENSSL_VERSION_PREREQ(3, 5)
1916             int X509_VERIFY_PARAM_get_purpose(Crypt::OpenSSL3::X509::VerifyParam param)
1917             #endif
1918              
1919             bool X509_VERIFY_PARAM_set_trust(Crypt::OpenSSL3::X509::VerifyParam param, int trust)
1920              
1921             void X509_VERIFY_PARAM_set_time(Crypt::OpenSSL3::X509::VerifyParam param, time_t t)
1922              
1923             time_t X509_VERIFY_PARAM_get_time(Crypt::OpenSSL3::X509::VerifyParam param)
1924              
1925             bool X509_VERIFY_PARAM_add_policy(Crypt::OpenSSL3::X509::VerifyParam param, Crypt::OpenSSL3::ASN1::Object policy)
1926             C_ARGS: param, ASN1_OBJECT_dup(policy)
1927              
1928             bool X509_VERIFY_PARAM_set_policies(Crypt::OpenSSL3::X509::VerifyParam param, STACK_OF(ASN1_OBJECT)* policies)
1929             POSTCALL:
1930 0           sk_ASN1_OBJECT_free(policies);
1931              
1932             void X509_VERIFY_PARAM_set_depth(Crypt::OpenSSL3::X509::VerifyParam param, int depth)
1933              
1934             int X509_VERIFY_PARAM_get_depth(Crypt::OpenSSL3::X509::VerifyParam param)
1935              
1936             void X509_VERIFY_PARAM_set_auth_level(Crypt::OpenSSL3::X509::VerifyParam param, int auth_level)
1937              
1938             int X509_VERIFY_PARAM_get_auth_level(Crypt::OpenSSL3::X509::VerifyParam param)
1939              
1940             char *X509_VERIFY_PARAM_get_host(Crypt::OpenSSL3::X509::VerifyParam param, int n)
1941              
1942             bool X509_VERIFY_PARAM_set_host(Crypt::OpenSSL3::X509::VerifyParam param, const char *name, size_t length(name))
1943              
1944             bool X509_VERIFY_PARAM_add_host(Crypt::OpenSSL3::X509::VerifyParam param, const char *name, size_t length(name))
1945              
1946             void X509_VERIFY_PARAM_set_hostflags(Crypt::OpenSSL3::X509::VerifyParam param, unsigned int flags)
1947              
1948             unsigned int X509_VERIFY_PARAM_get_hostflags(Crypt::OpenSSL3::X509::VerifyParam param)
1949              
1950             char *X509_VERIFY_PARAM_get_peername(Crypt::OpenSSL3::X509::VerifyParam param)
1951              
1952             char *X509_VERIFY_PARAM_get_email(Crypt::OpenSSL3::X509::VerifyParam param)
1953              
1954             bool X509_VERIFY_PARAM_set_email(Crypt::OpenSSL3::X509::VerifyParam param, const char *email, size_t length(email))
1955              
1956             char *X509_VERIFY_PARAM_get_ip_asc(Crypt::OpenSSL3::X509::VerifyParam param)
1957             CLEANUP:
1958 0           OPENSSL_free(RETVAL);
1959              
1960             bool X509_VERIFY_PARAM_set_ip(Crypt::OpenSSL3::X509::VerifyParam param, const unsigned char *ip, size_t length(ip))
1961              
1962             bool X509_VERIFY_PARAM_set_ip_asc(Crypt::OpenSSL3::X509::VerifyParam param, const char *ipasc)
1963              
1964              
1965             MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::X509::EDIPartyName PREFIX = EDIPARTYNAME_
1966              
1967             Crypt::OpenSSL3::X509::EDIPartyName EDIPARTYNAME_new(class)
1968             C_ARGS:
1969              
1970             ASN1_UTF8STRING* EDIPARTYNAME_get_name_assigner(Crypt::OpenSSL3::X509::EDIPartyName edi)
1971             POSTCALL:
1972 0 0         if (!RETVAL)
1973 0           XSRETURN_UNDEF;
1974              
1975             ASN1_UTF8STRING* EDIPARTYNAME_get_party_name(Crypt::OpenSSL3::X509::EDIPartyName edi)
1976              
1977             MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::X509::GeneralName PREFIX = GENERAL_NAME_
1978              
1979             Crypt::OpenSSL3::X509::GeneralName GENERAL_NAME_new(class)
1980             C_ARGS:
1981              
1982             #if OPENSSL_VERSION_PREREQ(3, 4)
1983             NO_OUTPUT int GENERAL_NAME_new_from_x509_name(OUTLIST Crypt::OpenSSL3::X509::GeneralName name, Crypt::OpenSSL3::X509::Name src)
1984             POSTCALL:
1985             if (!RETVAL)
1986             XSRETURN_UNDEF;
1987             #endif
1988              
1989             Crypt::OpenSSL3::X509::GeneralName GENERAL_NAME_dup(Crypt::OpenSSL3::X509::GeneralName gn)
1990              
1991             int GENERAL_NAME_type(Crypt::OpenSSL3::X509::GeneralName gn)
1992              
1993             SV* GENERAL_NAME_to_string(Crypt::OpenSSL3::X509::GeneralName gn)
1994             CODE:
1995 0           switch (gn->type) {
1996 0           case GEN_OTHERNAME:
1997 0           RETVAL = ASN1_TYPE_get_value(gn->d.otherName->value);
1998 0           break;
1999 0           case GEN_EMAIL:
2000             case GEN_DNS:
2001             case GEN_X400:
2002             case GEN_URI:
2003             case GEN_IPADD:
2004 0           RETVAL = ASN1_STRING_to_SV(V_ASN1_OCTET_STRING, gn->d.rfc822Name);
2005 0           break;
2006 0           case GEN_DIRNAME: {
2007 0           char* str = X509_NAME_oneline(gn->d.directoryName, NULL, 0);
2008 0           RETVAL = newSVpv(str, 0);
2009 0           OPENSSL_free(str);
2010 0           break;
2011             }
2012 0           case GEN_RID: {
2013 0           RETVAL = OBJ_to_text(gn->d.registeredID, 1);
2014 0           break;
2015             }
2016 0           case GEN_EDIPARTY: {
2017 0           RETVAL = EDIPARTYNAME_to_string(gn->d.ediPartyName);
2018 0           break;
2019             }
2020 0           default:
2021 0           RETVAL = &PL_sv_undef;
2022             }
2023             OUTPUT: RETVAL
2024              
2025             SV* GENERAL_NAME_to_value(Crypt::OpenSSL3::X509::GeneralName gn)
2026             CODE:
2027 0           switch (gn->type) {
2028 0           case GEN_OTHERNAME:
2029 0           RETVAL = make_ASN1_TYPE(aTHX_ ASN1_TYPE_dup(gn->d.otherName->value));
2030 0           break;
2031 0           case GEN_EMAIL:
2032             case GEN_DNS:
2033             case GEN_X400:
2034             case GEN_URI:
2035             case GEN_IPADD:
2036 0           RETVAL = ASN1_STRING_to_SV(V_ASN1_OCTET_STRING, gn->d.rfc822Name);
2037 0           break;
2038 0           case GEN_EDIPARTY:
2039 0           RETVAL = make_EDIPARTYNAME(aTHX_ EDIPARTYNAME_dup(gn->d.ediPartyName));
2040 0           break;
2041 0           case GEN_RID:
2042 0           RETVAL = make_ASN1_OBJECT(aTHX_ ASN1_OBJECT_dup(gn->d.registeredID));
2043 0           break;
2044 0           case GEN_DIRNAME:
2045 0           RETVAL = make_X509_NAME(aTHX_ X509_NAME_dup(gn->d.directoryName));
2046 0           break;
2047 0           default:
2048 0           RETVAL = &PL_sv_undef;
2049             }
2050             OUTPUT: RETVAL
2051              
2052              
2053             Crypt::OpenSSL3::X509::GeneralName GENERAL_NAME_decode_der(class, ASN1_DECODER* buffer)
2054             CODE:
2055 0           RETVAL = d2i_GENERAL_NAME(NULL, &buffer->ptr, buffer->end - buffer->ptr);
2056 0 0         if (!RETVAL)
2057 0           XSRETURN_UNDEF;
2058             OUTPUT: RETVAL
2059              
2060             SV* GENERAL_NAME_encode_der(Crypt::OpenSSL3::X509::GeneralName x)
2061             CODE:
2062 0           int length = i2d_GENERAL_NAME(x, NULL);
2063 0 0         if (length > 0) {
2064 0           unsigned char* ptr = make_buffer(&RETVAL, length);
2065 0           i2d_GENERAL_NAME(x, &ptr);
2066 0           set_buffer_length(RETVAL, length);
2067             } else
2068 0           RETVAL = &PL_sv_undef;
2069             OUTPUT: RETVAL
2070              
2071              
2072             MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::X509::Algorithm PREFIX = X509_ALGOR_
2073              
2074             Crypt::OpenSSL3::X509::Algorithm X509_ALGOR_new(class)
2075             C_ARGS:
2076              
2077             Crypt::OpenSSL3::X509::Algorithm X509_ALGOR_dup(Crypt::OpenSSL3::X509::Algorithm alg)
2078              
2079             bool X509_ALGOR_set(Crypt::OpenSSL3::X509::Algorithm alg, Crypt::OpenSSL3::ASN1::Object aobj)
2080             C_ARGS: alg, ASN1_OBJECT_dup(aobj), V_ASN1_UNDEF, NULL
2081              
2082             void X509_ALGOR_get(Crypt::OpenSSL3::X509::Algorithm alg, OUTLIST Crypt::OpenSSL3::ASN1::Object paobj)
2083             C_ARGS: (const ASN1_OBJECT**)&paobj, NULL, NULL, alg
2084              
2085             void X509_ALGOR_set_md(Crypt::OpenSSL3::X509::Algorithm alg, Crypt::OpenSSL3::MD md)
2086              
2087             int X509_ALGOR_cmp(Crypt::OpenSSL3::X509::Algorithm a, Crypt::OpenSSL3::X509::Algorithm b)
2088              
2089             bool X509_ALGOR_copy(Crypt::OpenSSL3::X509::Algorithm dest, Crypt::OpenSSL3::X509::Algorithm src)
2090              
2091             Crypt::OpenSSL3::X509::Algorithm X509_ALGOR_decode_der(class, ASN1_DECODER* buffer)
2092             CODE:
2093 0           RETVAL = d2i_X509_ALGOR(NULL, &buffer->ptr, buffer->end - buffer->ptr);
2094 0 0         if (!RETVAL)
2095 0           XSRETURN_UNDEF;
2096             OUTPUT: RETVAL
2097              
2098             SV* X509_ALGOR_encode_der(Crypt::OpenSSL3::X509::Algorithm x)
2099             CODE:
2100 0           int length = i2d_X509_ALGOR(x, NULL);
2101 0 0         if (length > 0) {
2102 0           unsigned char* ptr = make_buffer(&RETVAL, length);
2103 0           i2d_X509_ALGOR(x, &ptr);
2104 0           set_buffer_length(RETVAL, length);
2105             } else
2106 0           RETVAL = &PL_sv_undef;
2107             OUTPUT: RETVAL
2108              
2109              
2110             MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::X509::Attribute PREFIX = X509_ATTRIBUTE_
2111              
2112              
2113             Crypt::OpenSSL3::X509::Attribute X509_ATTRIBUTE_create(class, Crypt::OpenSSL3::NID nid, int atrtype, char *value)
2114             C_ARGS: nid, atrtype, value
2115              
2116             Crypt::OpenSSL3::X509::Attribute X509_ATTRIBUTE_create_by_NID(class, Crypt::OpenSSL3::NID nid, int atrtype, const char *data, int length(data))
2117             C_ARGS: NULL, nid, atrtype, data, XSauto_length_of_data
2118              
2119             Crypt::OpenSSL3::X509::Attribute X509_ATTRIBUTE_create_by_OBJ(class, Crypt::OpenSSL3::ASN1::Object obj, int atrtype, const char *data, int length(data))
2120             C_ARGS: NULL, obj, atrtype, data, XSauto_length_of_data
2121              
2122             Crypt::OpenSSL3::X509::Attribute X509_ATTRIBUTE_create_by_txt(class, const char *atrname, int type, const unsigned char *bytes, int length(bytes))
2123             C_ARGS: NULL, atrname, type, bytes, XSauto_length_of_bytes
2124              
2125             bool X509_ATTRIBUTE_set_object(Crypt::OpenSSL3::X509::Attribute attr, Crypt::OpenSSL3::ASN1::Object obj)
2126              
2127             bool X509_ATTRIBUTE_set_data(Crypt::OpenSSL3::X509::Attribute attr, int attrtype, const char *data, int length(data))
2128              
2129             const char *X509_ATTRIBUTE_get_data(Crypt::OpenSSL3::X509::Attribute attr, int idx, int atrtype)
2130             C_ARGS: attr, idx, atrtype, NULL
2131              
2132             PrintRet X509_ATTRIBUTE_count(Crypt::OpenSSL3::X509::Attribute attr)
2133              
2134             Crypt::OpenSSL3::ASN1::Object X509_ATTRIBUTE_get_object(Crypt::OpenSSL3::X509::Attribute attr)
2135             POSTCALL:
2136 0           RETVAL = ASN1_OBJECT_dup(RETVAL);
2137              
2138             Crypt::OpenSSL3::X509::Attribute X509_ATTRIBUTE_decode_der(class, ASN1_DECODER* buffer)
2139             CODE:
2140 0           RETVAL = d2i_X509_ATTRIBUTE(NULL, &buffer->ptr, buffer->end - buffer->ptr);
2141 0 0         if (!RETVAL)
2142 0           XSRETURN_UNDEF;
2143             OUTPUT: RETVAL
2144              
2145             SV* X509_ATTRIBUTE_encode_der(Crypt::OpenSSL3::X509::Attribute x)
2146             CODE:
2147 0           int length = i2d_X509_ATTRIBUTE(x, NULL);
2148 0 0         if (length > 0) {
2149 0           unsigned char* ptr = make_buffer(&RETVAL, length);
2150 0           i2d_X509_ATTRIBUTE(x, &ptr);
2151 0           set_buffer_length(RETVAL, length);
2152             } else
2153 0           RETVAL = &PL_sv_undef;
2154             OUTPUT: RETVAL
2155              
2156              
2157             MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::X509::Extension PREFIX = X509_EXTENSION_
2158              
2159             Crypt::OpenSSL3::X509::Extension X509_EXTENSION_new(class)
2160             C_ARGS:
2161              
2162             Crypt::OpenSSL3::X509::Extension X509_EXTENSION_dup(Crypt::OpenSSL3::X509::Extension ex)
2163              
2164             bool X509_EXTENSION_set_object(Crypt::OpenSSL3::X509::Extension ex, Crypt::OpenSSL3::ASN1::Object obj)
2165              
2166             bool X509_EXTENSION_set_critical(Crypt::OpenSSL3::X509::Extension ex, bool crit)
2167              
2168             bool X509_EXTENSION_set_data(Crypt::OpenSSL3::X509::Extension ex, ASN1_OCTET_STRING* data)
2169             CLEANUP:
2170 0           ASN1_STRING_free(data);
2171              
2172             Crypt::OpenSSL3::X509::Extension X509_EXTENSION_create_by_NID(Crypt::OpenSSL3::NID nid, bool crit, ASN1_OCTET_STRING* data)
2173             C_ARGS: NULL, nid, crit, data
2174             CLEANUP:
2175 0           ASN1_STRING_free(data);
2176              
2177             Crypt::OpenSSL3::X509::Extension X509_EXTENSION_create_by_OBJ(Crypt::OpenSSL3::ASN1::Object obj, bool crit, ASN1_OCTET_STRING* data)
2178             C_ARGS: NULL, obj, crit, data
2179             CLEANUP:
2180 0           ASN1_STRING_free(data);
2181              
2182             Crypt::OpenSSL3::ASN1::Object X509_EXTENSION_get_object(Crypt::OpenSSL3::X509::Extension ex)
2183             POSTCALL:
2184 0           RETVAL = ASN1_OBJECT_dup(RETVAL);
2185              
2186             bool X509_EXTENSION_get_critical(Crypt::OpenSSL3::X509::Extension ex)
2187              
2188             ASN1_OCTET_STRING* X509_EXTENSION_get_data(Crypt::OpenSSL3::X509::Extension ne)
2189              
2190             Crypt::OpenSSL3::X509::Extension X509_EXTENSION_decode_der(class, ASN1_DECODER* buffer)
2191             CODE:
2192 0           RETVAL = d2i_X509_EXTENSION(NULL, &buffer->ptr, buffer->end - buffer->ptr);
2193 0 0         if (!RETVAL)
2194 0           XSRETURN_UNDEF;
2195             OUTPUT: RETVAL
2196              
2197             SV* X509_EXTENSION_encode_der(Crypt::OpenSSL3::X509::Extension x)
2198             CODE:
2199 0           int length = i2d_X509_EXTENSION(x, NULL);
2200 0 0         if (length > 0) {
2201 0           unsigned char* ptr = make_buffer(&RETVAL, length);
2202 0           i2d_X509_EXTENSION(x, &ptr);
2203 0           set_buffer_length(RETVAL, length);
2204             } else
2205 0           RETVAL = &PL_sv_undef;
2206             OUTPUT: RETVAL
2207              
2208              
2209             MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::X509::VerifyResult PREFIX = X509_verify_cert_
2210              
2211             IV X509_verify_cert_error_code(Crypt::OpenSSL3::X509::VerifyResult result)
2212              
2213             bool X509_verify_cert_ok(Crypt::OpenSSL3::X509::VerifyResult result)
2214              
2215             const char* X509_verify_cert_error_string(Crypt::OpenSSL3::X509::VerifyResult result)
2216              
2217             MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::X509::Name PREFIX = X509_NAME_
2218              
2219             Crypt::OpenSSL3::X509::Name X509_NAME_new(class)
2220             C_ARGS:
2221              
2222             Crypt::OpenSSL3::X509::Name X509_NAME_dup(Crypt::OpenSSL3::X509::Name self)
2223              
2224             int X509_NAME_cmp(Crypt::OpenSSL3::X509::Name a, Crypt::OpenSSL3::X509::Name b)
2225              
2226             int X509_NAME_get_index_by_NID(Crypt::OpenSSL3::X509::Name name, Crypt::OpenSSL3::NID nid, int lastpos = -1)
2227             POSTCALL:
2228 0 0         if (RETVAL == -1)
2229 0           XSRETURN_UNDEF;
2230              
2231             int X509_NAME_get_index_by_OBJ(Crypt::OpenSSL3::X509::Name name, Crypt::OpenSSL3::ASN1::Object obj, int lastpos = -1)
2232             POSTCALL:
2233 0 0         if (RETVAL == -1)
2234 0           XSRETURN_UNDEF;
2235              
2236             int X509_NAME_entry_count(Crypt::OpenSSL3::X509::Name name)
2237              
2238             Crypt::OpenSSL3::X509::Name::Entry X509_NAME_get_entry(Crypt::OpenSSL3::X509::Name name, int loc)
2239             POSTCALL:
2240 0 0         if (RETVAL)
2241 0           RETVAL = X509_NAME_ENTRY_dup(RETVAL);
2242             else
2243 0           XSRETURN_UNDEF;
2244              
2245             char* X509_NAME_oneline(Crypt::OpenSSL3::X509::Name a)
2246             C_ARGS: a, NULL, 0
2247             CLEANUP:
2248 0 0         if (RETVAL)
2249 0           OPENSSL_free(RETVAL);
2250              
2251             NO_OUTPUT int X509_NAME_digest(Crypt::OpenSSL3::X509::Name data, Crypt::OpenSSL3::MD type, OUTLIST SV* hash)
2252             INIT:
2253 0           unsigned len = EVP_MD_size(type);
2254 0           unsigned char* ptr = make_buffer(&hash, len);
2255             C_ARGS: data, type, ptr, &len
2256             POSTCALL:
2257 0 0         if (RETVAL)
2258 0           set_buffer_length(hash, len);
2259              
2260             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)
2261              
2262             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)
2263              
2264             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)
2265              
2266             bool X509_NAME_add_entry(Crypt::OpenSSL3::X509::Name name, Crypt::OpenSSL3::X509::Name::Entry ne, int loc, int set)
2267              
2268             Crypt::OpenSSL3::X509::Name::Entry X509_NAME_delete_entry(Crypt::OpenSSL3::X509::Name name, int loc)
2269              
2270             int X509_NAME_print(Crypt::OpenSSL3::X509::Name nm, Crypt::OpenSSL3::BIO out, int indent = 0, unsigned long flags = 0)
2271             C_ARGS: out, nm, indent, flags
2272              
2273             unsigned long X509_NAME_hash(Crypt::OpenSSL3::X509::Name x, const char *propq = NULL)
2274             C_ARGS: x, NULL, propq, NULL
2275              
2276             Crypt::OpenSSL3::X509::Name X509_NAME_decode_der(class, ASN1_DECODER* buffer)
2277             CODE:
2278 0           RETVAL = d2i_X509_NAME(NULL, &buffer->ptr, buffer->end - buffer->ptr);
2279 0 0         if (!RETVAL)
2280 0           XSRETURN_UNDEF;
2281             OUTPUT: RETVAL
2282              
2283             SV* X509_NAME_encode_der(Crypt::OpenSSL3::X509::Name x)
2284             CODE:
2285 0           int length = i2d_X509_NAME(x, NULL);
2286 0 0         if (length > 0) {
2287 0           unsigned char* ptr = make_buffer(&RETVAL, length);
2288 0           i2d_X509_NAME(x, &ptr);
2289 0           set_buffer_length(RETVAL, length);
2290             } else
2291 0           RETVAL = &PL_sv_undef;
2292             OUTPUT: RETVAL
2293              
2294              
2295             MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::X509::Name::Entry PREFIX = X509_NAME_ENTRY
2296              
2297             Crypt::OpenSSL3::X509::Name::Entry X509_NAME_ENTRY_new(class)
2298             C_ARGS:
2299              
2300             Crypt::OpenSSL3::ASN1::Object X509_NAME_ENTRY_get_object(Crypt::OpenSSL3::X509::Name::Entry ne)
2301             POSTCALL:
2302 0 0         if (RETVAL)
2303 0           RETVAL = ASN1_OBJECT_dup(RETVAL);
2304             else
2305 0           XSRETURN_UNDEF;
2306              
2307             ASN1_OCTET_STRING* X509_NAME_ENTRY_get_data(Crypt::OpenSSL3::X509::Name::Entry ne)
2308             POSTCALL:
2309 0 0         if (!RETVAL)
2310 0           XSRETURN_UNDEF;
2311              
2312             bool X509_NAME_ENTRY_set_object(Crypt::OpenSSL3::X509::Name::Entry ne, Crypt::OpenSSL3::ASN1::Object obj)
2313              
2314             bool X509_NAME_ENTRY_set_data(Crypt::OpenSSL3::X509::Name::Entry ne, int type, const unsigned char *bytes, int length(bytes))
2315              
2316             MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::X509::Store PREFIX = X509_STORE_
2317              
2318             Crypt::OpenSSL3::X509::Store X509_STORE_new(class)
2319             C_ARGS:
2320              
2321             bool X509_STORE_lock(Crypt::OpenSSL3::X509::Store store)
2322              
2323             bool X509_STORE_unlock(Crypt::OpenSSL3::X509::Store store)
2324              
2325             bool X509_STORE_add_cert(Crypt::OpenSSL3::X509::Store store, Crypt::OpenSSL3::X509 x)
2326              
2327             bool X509_STORE_set_depth(Crypt::OpenSSL3::X509::Store store, int depth)
2328              
2329             bool X509_STORE_set_flags(Crypt::OpenSSL3::X509::Store store, unsigned long flags)
2330              
2331             bool X509_STORE_set_purpose(Crypt::OpenSSL3::X509::Store store, int purpose)
2332              
2333             bool X509_STORE_set_trust(Crypt::OpenSSL3::X509::Store store, int trust)
2334              
2335             bool X509_STORE_load_locations(Crypt::OpenSSL3::X509::Store store, const char *file, const char *dir)
2336              
2337             bool X509_STORE_set_default_paths(Crypt::OpenSSL3::X509::Store store)
2338              
2339             bool X509_STORE_load_file(Crypt::OpenSSL3::X509::Store xs, const char *file, const char *propq = NULL)
2340             C_ARGS: xs, file, NULL, propq
2341              
2342             bool X509_STORE_load_path(Crypt::OpenSSL3::X509::Store xs, const char *dir)
2343              
2344             bool X509_STORE_load_store(Crypt::OpenSSL3::X509::Store xs, const char *uri, const char *propq = NULL)
2345             C_ARGS: xs, uri, NULL, propq
2346              
2347             void X509_STORE_get_all_certs(Crypt::OpenSSL3::X509::Store xs)
2348             PPCODE:
2349 0           STACK_OF(X509)* stack = X509_STORE_get1_all_certs(xs);
2350 0 0         STACK_TO_STACK(X509, stack);
    0          
    0          
    0          
2351              
2352              
2353             MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::X509::Store::Context PREFIX = X509_STORE_CTX_
2354              
2355             Crypt::OpenSSL3::X509::Store::Context X509_STORE_CTX_new(const char *propq = NULL)
2356             C_ARGS: NULL, propq
2357              
2358             bool X509_STORE_CTX_init(Crypt::OpenSSL3::X509::Store::Context ctx, Crypt::OpenSSL3::X509::Store trust_store, Crypt::OpenSSL3::X509 target, STACK_OF(X509)* untrusted = NULL)
2359             POSTCALL:
2360 0           sk_X509_free(untrusted);
2361              
2362             #if OPENSSL_VERSION_PREREQ(3, 2)
2363              
2364             bool X509_STORE_CTX_init_rpk(Crypt::OpenSSL3::X509::Store::Context ctx, Crypt::OpenSSL3::X509::Store trust_store, Crypt::OpenSSL3::PKey rpk)
2365              
2366             void X509_STORE_CTX_set_rpk(Crypt::OpenSSL3::X509::Store::Context ctx, Crypt::OpenSSL3::PKey target)
2367             INIT:
2368             EVP_PKEY_up_ref(target);
2369              
2370             Crypt::OpenSSL3::PKey X509_STORE_CTX_get_rpk(Crypt::OpenSSL3::X509::Store::Context ctx)
2371             POSTCALL:
2372             if (RETVAL)
2373             EVP_PKEY_up_ref(RETVAL);
2374             else
2375             XSRETURN_UNDEF;
2376              
2377             #endif
2378              
2379             void X509_STORE_CTX_set_trusted_stack(Crypt::OpenSSL3::X509::Store::Context ctx, STACK_OF(X509)* sk)
2380              
2381             void X509_STORE_CTX_set_cert(Crypt::OpenSSL3::X509::Store::Context ctx, Crypt::OpenSSL3::X509 target)
2382              
2383             Crypt::OpenSSL3::X509::VerifyParam X509_STORE_CTX_get_param(Crypt::OpenSSL3::X509::Store::Context ctx)
2384              
2385             void X509_STORE_CTX_set_param(Crypt::OpenSSL3::X509::Store::Context ctx, Crypt::OpenSSL3::X509::VerifyParam param)
2386              
2387             void X509_STORE_CTX_get_untrusted(Crypt::OpenSSL3::X509::Store::Context ctx)
2388             PPCODE:
2389 0           STACK_OF(X509)* stack = X509_STORE_CTX_get0_untrusted(ctx);
2390 0 0         CSTACK_TO_STACK(X509, stack);
    0          
    0          
    0          
2391              
2392             void X509_STORE_CTX_set_untrusted(Crypt::OpenSSL3::X509::Store::Context ctx, STACK_OF(X509)* sk)
2393              
2394             int X509_STORE_CTX_get_num_untrusted(Crypt::OpenSSL3::X509::Store::Context ctx)
2395              
2396             void X509_STORE_CTX_get_chain(Crypt::OpenSSL3::X509::Store::Context ctx)
2397             PPCODE:
2398 0           STACK_OF(X509)* stack = X509_STORE_CTX_get0_chain(ctx);
2399 0 0         CSTACK_TO_STACK(X509, stack);
    0          
    0          
    0          
2400              
2401             void X509_STORE_CTX_set_verified_chain(Crypt::OpenSSL3::X509::Store::Context ctx, STACK_OF(X509)* chain)
2402              
2403             bool X509_STORE_CTX_set_default(Crypt::OpenSSL3::X509::Store::Context ctx, const char *name)
2404              
2405             bool X509_STORE_CTX_set_purpose(Crypt::OpenSSL3::X509::Store::Context ctx, int purpose)
2406              
2407             bool X509_STORE_CTX_set_trust(Crypt::OpenSSL3::X509::Store::Context ctx, int trust)
2408              
2409             int X509_STORE_CTX_purpose_inherit(Crypt::OpenSSL3::X509::Store::Context ctx, int def_purpose, int purpose, int trust)
2410              
2411             void X509_STORE_CTX_set_time(Crypt::OpenSSL3::X509::Store::Context ctx, time_t t, unsigned long flags = 0)
2412             C_ARGS: ctx, flags, t
2413              
2414             int X509_STORE_CTX_verify(Crypt::OpenSSL3::X509::Store::Context ctx)
2415              
2416             int X509_STORE_CTX_get_error(Crypt::OpenSSL3::X509::Store::Context ctx)
2417              
2418             const char *X509_STORE_CTX_get_error_string(Crypt::OpenSSL3::X509::Store::Context ctx)
2419             CODE:
2420 0           int code = X509_STORE_CTX_get_error(ctx);
2421 0           RETVAL = X509_verify_cert_error_string(code);
2422             OUTPUT: RETVAL
2423              
2424             void X509_STORE_CTX_set_error(Crypt::OpenSSL3::X509::Store::Context ctx, int s)
2425              
2426             int X509_STORE_CTX_get_error_depth(Crypt::OpenSSL3::X509::Store::Context ctx)
2427              
2428             void X509_STORE_CTX_set_error_depth(Crypt::OpenSSL3::X509::Store::Context ctx, int depth)
2429              
2430             Crypt::OpenSSL3::X509 X509_STORE_CTX_get_cert(Crypt::OpenSSL3::X509::Store::Context ctx)
2431             POSTCALL:
2432 0 0         if (RETVAL)
2433 0           X509_up_ref(RETVAL);
2434             else
2435 0           XSRETURN_UNDEF;
2436              
2437             MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::X509::Request PREFIX = X509_REQ_
2438              
2439             Crypt::OpenSSL3::X509::Request X509_REQ_new(class, const char *propq = NULL)
2440             C_ARGS: NULL, propq
2441              
2442             Crypt::OpenSSL3::X509::Request X509_REQ_dup(Crypt::OpenSSL3::X509::Request req)
2443              
2444             Crypt::OpenSSL3::X509::Request X509_REQ_read_pem(class, Crypt::OpenSSL3::BIO bio)
2445             C_ARGS: bio, NULL, NULL, NULL
2446             POSTCALL:
2447 0 0         if (!RETVAL)
2448 0           XSRETURN_UNDEF;
2449              
2450             bool X509_REQ_write_pem(Crypt::OpenSSL3::X509::Request x, Crypt::OpenSSL3::BIO bio)
2451             C_ARGS: bio, x
2452              
2453             Crypt::OpenSSL3::X509::Request X509_REQ_read_der(class, Crypt::OpenSSL3::BIO bio)
2454             C_ARGS: bio, NULL
2455             POSTCALL:
2456 0 0         if (!RETVAL)
2457 0           XSRETURN_UNDEF;
2458              
2459             bool X509_REQ_write_der(Crypt::OpenSSL3::X509::Request x, Crypt::OpenSSL3::BIO bio)
2460             C_ARGS: bio, x
2461              
2462             Crypt::OpenSSL3::X509::Request X509_REQ_decode_der(class, ASN1_DECODER* buffer)
2463             CODE:
2464 0           RETVAL = d2i_X509_REQ(NULL, &buffer->ptr, buffer->end - buffer->ptr);
2465 0 0         if (!RETVAL)
2466 0           XSRETURN_UNDEF;
2467             OUTPUT: RETVAL
2468              
2469             SV* X509_REQ_encode_der(Crypt::OpenSSL3::X509::Request x)
2470             CODE:
2471 0           int length = i2d_X509_REQ(x, NULL);
2472 0 0         if (length > 0) {
2473 0           unsigned char* ptr = make_buffer(&RETVAL, length);
2474 0           i2d_X509_REQ(x, &ptr);
2475 0           set_buffer_length(RETVAL, length);
2476             } else
2477 0           RETVAL = &PL_sv_undef;
2478             OUTPUT: RETVAL
2479              
2480             SV* X509_REQ_encode_der_tbs(Crypt::OpenSSL3::X509::Request x)
2481             CODE:
2482 0           int length = i2d_re_X509_REQ_tbs(x, NULL);
2483 0 0         if (length > 0) {
2484 0           unsigned char* ptr = make_buffer(&RETVAL, length);
2485 0           i2d_re_X509_REQ_tbs(x, &ptr);
2486 0           set_buffer_length(RETVAL, length);
2487             } else
2488 0           RETVAL = &PL_sv_undef;
2489             OUTPUT: RETVAL
2490              
2491             int X509_REQ_get_attr_count(Crypt::OpenSSL3::X509::Request req)
2492              
2493             int X509_REQ_get_attr_by_NID(Crypt::OpenSSL3::X509::Request req, Crypt::OpenSSL3::NID nid, int lastpos = -1)
2494             POSTCALL:
2495 0 0         if (RETVAL == -1)
2496 0           XSRETURN_UNDEF;
2497              
2498             int X509_REQ_get_attr_by_OBJ(Crypt::OpenSSL3::X509::Request req, Crypt::OpenSSL3::ASN1::Object obj, int lastpos = -1)
2499             POSTCALL:
2500 0 0         if (RETVAL == -1)
2501 0           XSRETURN_UNDEF;
2502              
2503             Crypt::OpenSSL3::X509::Attribute X509_REQ_get_attr(Crypt::OpenSSL3::X509::Request req, int loc)
2504             POSTCALL:
2505 0 0         if (!RETVAL)
2506 0           XSRETURN_UNDEF;
2507              
2508             Crypt::OpenSSL3::X509::Attribute X509_REQ_delete_attr(Crypt::OpenSSL3::X509::Request req, int loc)
2509             POSTCALL:
2510 0 0         if (!RETVAL)
2511 0           XSRETURN_UNDEF;
2512              
2513             bool X509_REQ_add_attr(Crypt::OpenSSL3::X509::Request req, Crypt::OpenSSL3::X509::Attribute attr)
2514              
2515             bool X509_REQ_add_attr_by_OBJ(Crypt::OpenSSL3::X509::Request req, Crypt::OpenSSL3::ASN1::Object obj, int type, const unsigned char *bytes, int length(bytes))
2516              
2517             bool X509_REQ_add_attr_by_NID(Crypt::OpenSSL3::X509::Request req, Crypt::OpenSSL3::NID nid, int type, const unsigned char *bytes, int len)
2518              
2519             bool X509_REQ_add_attr_by_txt(Crypt::OpenSSL3::X509::Request req, const char *attrname, int type, const unsigned char *bytes, int len)
2520              
2521             void X509_REQ_get_extensions(Crypt::OpenSSL3::X509::Request req)
2522             PPCODE:
2523 0           STACK_OF(X509_EXTENSION)* exts = X509_REQ_get_extensions(req);
2524 0 0         CSTACK_TO_STACK(X509_EXTENSION, exts);
    0          
    0          
    0          
2525              
2526             bool X509_REQ_add_extensions(Crypt::OpenSSL3::X509::Request req, STACK_OF(X509_EXTENSION) *exts)
2527             POSTCALL:
2528 0           sk_X509_EXTENSION_free(exts);
2529              
2530             bool X509_REQ_add_extensions_nid(Crypt::OpenSSL3::X509::Request req, STACK_OF(X509_EXTENSION) *exts, Crypt::OpenSSL3::NID nid)
2531             POSTCALL:
2532 0           sk_X509_EXTENSION_free(exts);
2533              
2534             bool X509_REQ_check_private_key(Crypt::OpenSSL3::X509::Request cert, Crypt::OpenSSL3::PKey pkey)
2535              
2536             NO_OUTPUT Bool X509_REQ_digest(Crypt::OpenSSL3::X509::Request data, Crypt::OpenSSL3::MD type, OUTLIST SV* digest)
2537             INIT:
2538 0           unsigned int output_length = EVP_MD_size(type);
2539 0           unsigned char* ptr = make_buffer(&digest, output_length);
2540             C_ARGS: data, type, ptr, &output_length
2541             POSTCALL:
2542 0 0         if (RETVAL)
2543 0           set_buffer_length(digest, output_length);
2544              
2545             ASN1_OCTET_STRING* X509_REQ_get_distinguishing_id(Crypt::OpenSSL3::X509::Request x)
2546              
2547             void X509_REQ_set_distinguishing_id(Crypt::OpenSSL3::X509::Request x, ASN1_OCTET_STRING* distid)
2548              
2549             Crypt::OpenSSL3::PKey X509_REQ_get_pubkey(Crypt::OpenSSL3::X509::Request x)
2550              
2551             bool X509_REQ_set_pubkey(Crypt::OpenSSL3::X509::Request x, Crypt::OpenSSL3::PKey pkey)
2552              
2553              
2554             Crypt::OpenSSL3::X509::Name X509_REQ_get_subject_name(Crypt::OpenSSL3::X509::Request x)
2555             POSTCALL:
2556 0           RETVAL = X509_NAME_dup(RETVAL);
2557              
2558             bool X509_REQ_set_subject_name(Crypt::OpenSSL3::X509::Request x, Crypt::OpenSSL3::X509::Name name)
2559              
2560             void X509_REQ_set_signature(Crypt::OpenSSL3::X509::Request req, ASN1_OCTET_STRING* psig)
2561              
2562             void X509_REQ_get_signature(Crypt::OpenSSL3::X509::Request req, OUTLIST const ASN1_OCTET_STRING* psig, OUTLIST Crypt::OpenSSL3::X509::Algorithm palg)
2563             C_ARGS: req, &psig, (const X509_ALGOR**)&palg
2564             POSTCALL:
2565 0           palg = X509_ALGOR_dup(palg);
2566            
2567             int X509_REQ_set_signature_algo(Crypt::OpenSSL3::X509::Request req, Crypt::OpenSSL3::X509::Algorithm palg)
2568              
2569             Crypt::OpenSSL3::NID X509_REQ_get_signature_nid(Crypt::OpenSSL3::X509::Request req)
2570              
2571             long X509_REQ_get_version(Crypt::OpenSSL3::X509::Request req)
2572              
2573             int X509_REQ_set_version(Crypt::OpenSSL3::X509::Request x, long version)
2574              
2575             int X509_REQ_verify(Crypt::OpenSSL3::X509::Request a, Crypt::OpenSSL3::PKey r, const char *propq = NULL)
2576             C_ARGS: a, r, NULL, propq
2577              
2578             int X509_REQ_sign(Crypt::OpenSSL3::X509::Request x, Crypt::OpenSSL3::PKey pkey, Crypt::OpenSSL3::MD md)
2579              
2580             int X509_REQ_sign_ctx(Crypt::OpenSSL3::X509::Request x, Crypt::OpenSSL3::MD::Context ctx)
2581              
2582              
2583             MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::X509::Transparency::Log::Store PREFIX = CTLOG_STORE_
2584              
2585             Crypt::OpenSSL3::X509::Transparency::Log::Store CTLOG_STORE_new(const char *propq = NULL)
2586             C_ARGS: NULL, propq
2587              
2588             #if OPENSSL_VERSION_PREREQ(4, 1)
2589             bool CTLOG_STORE_add_log_key(Crypt::OpenSSL3::X509::Transparency::Log::Store store, Crypt::OpenSSL3::PKey pkey, const char* name, const char* propq = NULL)
2590             CODE:
2591             CTLOG* log = CTLOG_new_ex(pkey, name, NULL, propq);
2592             RETVAL = CTLOG_STORE_add0_log(store, log);
2593             OUTPUT: RETVAL
2594              
2595             bool CTLOG_STORE_add_log_base64(Crypt::OpenSSL3::X509::Transparency::Log::Store store, const char* base64, const char* name, const char* propq = NULL)
2596             CODE:
2597             CTLOG* log = CTLOG_new_from_base64_ex(base64, name, NULL, propq);
2598             RETVAL = CTLOG_STORE_add0_log(store, log);
2599             OUTPUT: RETVAL
2600             #endif
2601              
2602             bool CTLOG_STORE_load_default_file(Crypt::OpenSSL3::X509::Transparency::Log::Store store)
2603              
2604             bool CTLOG_STORE_load_file(Crypt::OpenSSL3::X509::Transparency::Log::Store store, const char *file)
2605              
2606             Bool CLONE_SKIP(...)
2607              
2608              
2609             MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::X509::Transparency::Evaluator PREFIX = CT_POLICY_EVAL_CTX_
2610              
2611             Crypt::OpenSSL3::X509::Transparency::Evaluator CT_POLICY_EVAL_CTX_new(const char *propq = NULL)
2612             C_ARGS: NULL, propq
2613              
2614             Crypt::OpenSSL3::X509 CT_POLICY_EVAL_CTX_get_cert(Crypt::OpenSSL3::X509::Transparency::Evaluator ctx)
2615             POSTCALL:
2616 0           X509_up_ref(RETVAL);
2617              
2618             bool CT_POLICY_EVAL_CTX_set_cert(Crypt::OpenSSL3::X509::Transparency::Evaluator ctx, Crypt::OpenSSL3::X509 cert)
2619              
2620             Crypt::OpenSSL3::X509 CT_POLICY_EVAL_CTX_get_issuer(Crypt::OpenSSL3::X509::Transparency::Evaluator ctx)
2621             POSTCALL:
2622 0           X509_up_ref(RETVAL);
2623              
2624             bool CT_POLICY_EVAL_CTX_set_issuer(Crypt::OpenSSL3::X509::Transparency::Evaluator ctx, Crypt::OpenSSL3::X509 issuer)
2625              
2626             void CT_POLICY_EVAL_CTX_set_log_store(Crypt::OpenSSL3::X509::Transparency::Evaluator ctx, Crypt::OpenSSL3::X509::Transparency::Log::Store log_store)
2627              
2628             uint64_t CT_POLICY_EVAL_CTX_get_time(Crypt::OpenSSL3::X509::Transparency::Evaluator ctx)
2629              
2630             void CT_POLICY_EVAL_CTX_set_time(Crypt::OpenSSL3::X509::Transparency::Evaluator ctx, uint64_t time_in_ms)
2631              
2632             Bool CLONE_SKIP(...)
2633              
2634              
2635             MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::X509::Transparency::Timestamp PREFIX = SCT_
2636              
2637             BOOT:
2638             {
2639 62           HV* stash = gv_stashpvs("Crypt::OpenSSL3::X509::Transparency::Timestamp", GV_ADD | GV_ADDMULTI);
2640 62           CONSTANT2(CT_LOG_, ENTRY_TYPE_NOT_SET);
2641 62           CONSTANT2(CT_LOG_, ENTRY_TYPE_X509);
2642 62           CONSTANT2(CT_LOG_, ENTRY_TYPE_PRECERT);
2643              
2644 62           CONSTANT2(SCT_, VERSION_NOT_SET);
2645 62           CONSTANT2(SCT_, VERSION_V1);
2646              
2647 62           CONSTANT2(SCT_, SOURCE_UNKNOWN);
2648 62           CONSTANT2(SCT_, SOURCE_TLS_EXTENSION);
2649 62           CONSTANT2(SCT_, SOURCE_X509V3_EXTENSION);
2650 62           CONSTANT2(SCT_, SOURCE_OCSP_STAPLED_RESPONSE);
2651              
2652 62           CONSTANT2(SCT_, VALIDATION_STATUS_NOT_SET);
2653 62           CONSTANT2(SCT_, VALIDATION_STATUS_UNKNOWN_LOG);
2654 62           CONSTANT2(SCT_, VALIDATION_STATUS_VALID);
2655 62           CONSTANT2(SCT_, VALIDATION_STATUS_INVALID);
2656 62           CONSTANT2(SCT_, VALIDATION_STATUS_UNVERIFIED);
2657 62           CONSTANT2(SCT_, VALIDATION_STATUS_UNKNOWN_VERSION);
2658             }
2659              
2660             Crypt::OpenSSL3::X509::Transparency::Timestamp SCT_new()
2661              
2662             Crypt::OpenSSL3::X509::Transparency::Timestamp SCT_new_from_base64(unsigned char version, const char *logid_base64, int entry_type, uint64_t timestamp, const char *extensions_base64, const char *signature_base64)
2663              
2664             int SCT_get_version(Crypt::OpenSSL3::X509::Transparency::Timestamp sct)
2665              
2666             bool SCT_set_version(Crypt::OpenSSL3::X509::Transparency::Timestamp sct, int version)
2667              
2668             int SCT_get_log_entry_type(Crypt::OpenSSL3::X509::Transparency::Timestamp sct)
2669              
2670             bool SCT_set_log_entry_type(Crypt::OpenSSL3::X509::Transparency::Timestamp sct, int entry_type)
2671              
2672             NO_OUTPUT size_t SCT_get_log_id(Crypt::OpenSSL3::X509::Transparency::Timestamp sct, OUTLIST SV* out)
2673             INTERFACE: SCT_get_log_id SCT_get_signature SCT_get_extensions
2674             INIT:
2675             unsigned char* buffer;
2676             C_ARGS: sct, &buffer
2677             POSTCALL:
2678 0           out = newSVpvn(buffer, RETVAL);
2679              
2680             bool SCT_set_log_id(Crypt::OpenSSL3::X509::Transparency::Timestamp sct, const unsigned char *log_id, size_t length(log_id))
2681              
2682             uint64_t SCT_get_timestamp(Crypt::OpenSSL3::X509::Transparency::Timestamp sct)
2683              
2684             void SCT_set_timestamp(Crypt::OpenSSL3::X509::Transparency::Timestamp sct, uint64_t timestamp)
2685              
2686             Crypt::OpenSSL3::NID SCT_get_signature_nid(Crypt::OpenSSL3::X509::Transparency::Timestamp sct)
2687              
2688             bool SCT_set_signature_nid(Crypt::OpenSSL3::X509::Transparency::Timestamp sct, Crypt::OpenSSL3::NID nid)
2689              
2690             bool SCT_set_signature(Crypt::OpenSSL3::X509::Transparency::Timestamp sct, const unsigned char *sig, size_t length(sig))
2691              
2692             bool SCT_set_extensions(Crypt::OpenSSL3::X509::Transparency::Timestamp sct, const unsigned char *ext, size_t length(ext))
2693              
2694             int SCT_get_source(Crypt::OpenSSL3::X509::Transparency::Timestamp sct)
2695              
2696             bool SCT_set_source(Crypt::OpenSSL3::X509::Transparency::Timestamp sct, int source)
2697              
2698             Success SCT_validate(Crypt::OpenSSL3::X509::Transparency::Timestamp sct, Crypt::OpenSSL3::X509::Transparency::Evaluator ctx)
2699              
2700             int SCT_get_validation_status(Crypt::OpenSSL3::X509::Transparency::Timestamp sct)
2701              
2702             void SCT_print(Crypt::OpenSSL3::X509::Transparency::Timestamp sct, Crypt::OpenSSL3::BIO out, int indent, Crypt::OpenSSL3::X509::Transparency::Log::Store logs)
2703              
2704             Crypt::OpenSSL3::X509::Transparency::Timestamp SCT_decode(class, ASN1_DECODER* buffer)
2705             CODE:
2706 0           RETVAL = o2i_SCT(NULL, &buffer->ptr, buffer->end - buffer->ptr);
2707 0 0         if (!RETVAL)
2708 0           XSRETURN_UNDEF;
2709             OUTPUT: RETVAL
2710              
2711             SV* SCT_encode(Crypt::OpenSSL3::X509::Transparency::Timestamp sct)
2712             CODE:
2713 0           int length = i2o_SCT(sct, NULL);
2714 0 0         if (length > 0) {
2715 0           unsigned char* ptr = make_buffer(&RETVAL, length);
2716 0           i2o_SCT(sct, &ptr);
2717 0           set_buffer_length(RETVAL, length);
2718             } else
2719 0           RETVAL = &PL_sv_undef;
2720             OUTPUT: RETVAL
2721              
2722             MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::PKCS7 PREFIX = PKCS7_
2723              
2724             BOOT:
2725             {
2726 62           HV* stash = gv_stashpvs("Crypt::OpenSSL3::PKCS7", GV_ADD | GV_ADDMULTI);
2727 62           CONSTANT2(PKCS7_, TEXT);
2728 62           CONSTANT2(PKCS7_, BINARY);
2729 62           CONSTANT2(PKCS7_, NOCERTS);
2730 62           CONSTANT2(PKCS7_, DETACHED);
2731 62           CONSTANT2(PKCS7_, NOATTR);
2732 62           CONSTANT2(PKCS7_, NOSMIMECAP);
2733 62           CONSTANT2(PKCS7_, STREAM);
2734              
2735 62           CONSTANT2(PKCS7_, NOINTERN);
2736 62           CONSTANT2(PKCS7_, NOCRL);
2737 62           CONSTANT2(PKCS7_, NOVERIFY);
2738 62           CONSTANT2(PKCS7_, NOCHAIN);
2739 62           CONSTANT2(PKCS7_, NOSIGS);
2740             }
2741              
2742             Crypt::OpenSSL3::PKCS7 PKCS7_new(class, const char* propq = NULL)
2743             C_ARGS: NULL, propq
2744              
2745             Crypt::OpenSSL3::PKCS7 PKCS7_read_pem(class, Crypt::OpenSSL3::BIO bio)
2746             C_ARGS: bio, NULL, NULL, NULL
2747             POSTCALL:
2748 0 0         if (!RETVAL)
2749 0           XSRETURN_UNDEF;
2750              
2751             bool PKCS7_write_pem(Crypt::OpenSSL3::PKCS7 x, Crypt::OpenSSL3::BIO bio)
2752             C_ARGS: bio, x
2753              
2754             Crypt::OpenSSL3::PKCS7 PKCS7_read_der(class, Crypt::OpenSSL3::BIO bp)
2755             C_ARGS: bp, NULL
2756             POSTCALL:
2757 0 0         if (!RETVAL)
2758 0           XSRETURN_UNDEF;
2759              
2760             int PKCS7_write_der(Crypt::OpenSSL3::PKCS7 p7, Crypt::OpenSSL3::BIO bio)
2761             C_ARGS: bio, p7
2762              
2763             Crypt::OpenSSL3::PKCS7 PKCS7_decode_der(class, ASN1_DECODER* buffer)
2764             CODE:
2765 0           RETVAL = d2i_PKCS7(NULL, &buffer->ptr, buffer->end - buffer->ptr);
2766 0 0         if (!RETVAL)
2767 0           XSRETURN_UNDEF;
2768             OUTPUT: RETVAL
2769              
2770             SV* PKCS7_encode_der(Crypt::OpenSSL3::PKCS7 x)
2771             CODE:
2772 0           int length = i2d_PKCS7(x, NULL);
2773 0 0         if (length > 0) {
2774 0           unsigned char* ptr = make_buffer(&RETVAL, length);
2775 0           i2d_PKCS7(x, &ptr);
2776 0           set_buffer_length(RETVAL, length);
2777             } else
2778 0           RETVAL = &PL_sv_undef;
2779             OUTPUT: RETVAL
2780              
2781             bool PKCS7_add_certificate(Crypt::OpenSSL3::PKCS7 p7, Crypt::OpenSSL3::X509 cert)
2782              
2783             Crypt::OpenSSL3::PKCS7 PKCS7_sign(class, Crypt::OpenSSL3::X509 signcert, Crypt::OpenSSL3::PKey pkey, STACK_OF(X509)* certs, Crypt::OpenSSL3::BIO data, int flags, const char *propq = NULL)
2784             C_ARGS: signcert, pkey, certs, data, flags, NULL, propq
2785             POSTCALL:
2786 0           sk_X509_free(certs);
2787              
2788             bool PKCS7_verify(Crypt::OpenSSL3::PKCS7 p7, STACK_OF(X509)* certs, Crypt::OpenSSL3::X509::Store store, Crypt::OpenSSL3::BIO indata, Crypt::OpenSSL3::BIO out, int flags)
2789             POSTCALL:
2790 0           sk_X509_free(certs);
2791              
2792             void PKCS7_get_signers(Crypt::OpenSSL3::PKCS7 p7, STACK_OF(X509)* certs, int flags = 0)
2793             PPCODE:
2794 0           STACK_OF(X509)* stack = PKCS7_get0_signers(p7, certs, flags);
2795 0 0         CSTACK_TO_STACK(X509, stack);
    0          
    0          
    0          
2796 0           sk_X509_free(stack);
2797              
2798             Crypt::OpenSSL3::PKCS7 PKCS7_encrypt(class, STACK_OF(X509)* certs, Crypt::OpenSSL3::BIO in, Crypt::OpenSSL3::Cipher cipher, int flags, const char* propq = NULL)
2799             C_ARGS: certs, in, cipher, flags, NULL, propq
2800             POSTCALL:
2801 0           sk_X509_free(certs);
2802              
2803             bool PKCS7_decrypt(Crypt::OpenSSL3::PKCS7 p7, Crypt::OpenSSL3::PKey pkey, Crypt::OpenSSL3::X509 cert, Crypt::OpenSSL3::BIO data, int flags)
2804              
2805             ASN1_OCTET_STRING* PKCS7_get_octet_string(Crypt::OpenSSL3::PKCS7 p7);
2806              
2807             bool PKCS7_type_is_signed(Crypt::OpenSSL3::PKCS7 a)
2808              
2809             bool PKCS7_type_is_encrypted(Crypt::OpenSSL3::PKCS7 a)
2810              
2811             bool PKCS7_type_is_enveloped(Crypt::OpenSSL3::PKCS7 a)
2812              
2813             bool PKCS7_type_is_signedAndEnveloped(Crypt::OpenSSL3::PKCS7 a)
2814              
2815             bool PKCS7_type_is_data(Crypt::OpenSSL3::PKCS7 a)
2816              
2817             bool PKCS7_type_is_digest(Crypt::OpenSSL3::PKCS7 a)
2818              
2819             bool PKCS7_type_is_other(Crypt::OpenSSL3::PKCS7 p7)
2820              
2821              
2822              
2823             MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::SSL::Method PREFIX = SSL_Method_
2824              
2825             Crypt::OpenSSL3::SSL::Method SSL_Method_TLS()
2826              
2827             Crypt::OpenSSL3::SSL::Method SSL_Method_TLS_server()
2828              
2829             Crypt::OpenSSL3::SSL::Method SSL_Method_TLS_client()
2830              
2831             Crypt::OpenSSL3::SSL::Method SSL_Method_DTLS()
2832              
2833             Crypt::OpenSSL3::SSL::Method SSL_Method_DTLS_server()
2834              
2835             Crypt::OpenSSL3::SSL::Method SSL_Method_DTLS_client()
2836              
2837             #if OPENSSL_VERSION_PREREQ(3, 2)
2838             Crypt::OpenSSL3::SSL::Method SSL_Method_QUIC_client()
2839              
2840             Crypt::OpenSSL3::SSL::Method SSL_Method_QUIC_client_thread()
2841             #endif
2842              
2843             #if OPENSSL_VERSION_PREREQ(3, 5)
2844             Crypt::OpenSSL3::SSL::Method SSL_Method_QUIC_server()
2845             #endif
2846              
2847             MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::SSL::Context PREFIX = SSL_CTX_
2848              
2849             Crypt::OpenSSL3::SSL::Context SSL_CTX_new(classname, Crypt::OpenSSL3::SSL::Method method = TLS_method())
2850             C_ARGS: method
2851              
2852             long SSL_CTX_set_options(Crypt::OpenSSL3::SSL::Context ctx, long options)
2853              
2854             long SSL_CTX_clear_options(Crypt::OpenSSL3::SSL::Context ctx, long options)
2855              
2856             long SSL_CTX_get_options(Crypt::OpenSSL3::SSL::Context ctx)
2857              
2858             void SSL_CTX_set_read_ahead(Crypt::OpenSSL3::SSL::Context ctx, bool yes)
2859              
2860             bool SSL_CTX_get_read_ahead(Crypt::OpenSSL3::SSL::Context ctx)
2861              
2862             bool SSL_CTX_set_session_id_context(Crypt::OpenSSL3::SSL::Context ctx, const unsigned char *sid_ctx, unsigned int length(sid_ctx))
2863              
2864             long SSL_CTX_set_mode(Crypt::OpenSSL3::SSL::Context ctx, long mode)
2865              
2866             long SSL_CTX_clear_mode(Crypt::OpenSSL3::SSL::Context ctx, long mode)
2867              
2868             long SSL_CTX_get_mode(Crypt::OpenSSL3::SSL::Context ctx)
2869              
2870             bool SSL_CTX_set_min_proto_version(Crypt::OpenSSL3::SSL::Context ctx, int version)
2871              
2872             bool SSL_CTX_set_max_proto_version(Crypt::OpenSSL3::SSL::Context ctx, int version)
2873              
2874             int SSL_CTX_get_min_proto_version(Crypt::OpenSSL3::SSL::Context ctx)
2875              
2876             int SSL_CTX_get_max_proto_version(Crypt::OpenSSL3::SSL::Context ctx)
2877              
2878             bool SSL_CTX_set_alpn_protos(Crypt::OpenSSL3::SSL::Context ctx, const unsigned char *protos, unsigned int length(protos))
2879              
2880             Crypt::OpenSSL3::X509::Store SSL_CTX_get_cert_store(Crypt::OpenSSL3::SSL::Context ctx)
2881             POSTCALL:
2882 0           X509_STORE_up_ref(RETVAL);
2883              
2884             void SSL_CTX_set_cert_store(Crypt::OpenSSL3::SSL::Context ctx, Crypt::OpenSSL3::X509::Store store)
2885             POSTCALL:
2886 0           X509_STORE_up_ref(store);
2887              
2888             bool SSL_CTX_load_verify_locations(Crypt::OpenSSL3::SSL::Context ctx, const char *CAfile, const char *CApath)
2889              
2890             bool SSL_CTX_load_verify_file(Crypt::OpenSSL3::SSL::Context ctx, const char *CAfile)
2891              
2892             bool SSL_CTX_load_verify_dir(Crypt::OpenSSL3::SSL::Context ctx, const char *CApath)
2893              
2894             bool SSL_CTX_load_verify_store(Crypt::OpenSSL3::SSL::Context ctx, const char *CAstore)
2895              
2896             bool SSL_CTX_set_default_verify_paths(Crypt::OpenSSL3::SSL::Context ctx)
2897              
2898             bool SSL_CTX_set_default_verify_dir(Crypt::OpenSSL3::SSL::Context ctx)
2899              
2900             bool SSL_CTX_set_default_verify_file(Crypt::OpenSSL3::SSL::Context ctx)
2901              
2902             bool SSL_CTX_use_certificate(Crypt::OpenSSL3::SSL::Context ctx, Crypt::OpenSSL3::X509 x)
2903              
2904             bool SSL_CTX_use_certificate_ASN1(Crypt::OpenSSL3::SSL::Context ctx, int length(d), const unsigned char *d)
2905              
2906             bool SSL_CTX_use_certificate_file(Crypt::OpenSSL3::SSL::Context ctx, const char *file, int type)
2907              
2908             bool SSL_CTX_use_certificate_chain_file(Crypt::OpenSSL3::SSL::Context ctx, const char *file)
2909              
2910             long SSL_CTX_add_extra_chain_cert(Crypt::OpenSSL3::SSL::Context ctx, Crypt::OpenSSL3::X509 x509)
2911              
2912             long SSL_CTX_clear_extra_chain_certs(Crypt::OpenSSL3::SSL::Context ctx)
2913              
2914             bool SSL_CTX_use_PrivateKey(Crypt::OpenSSL3::SSL::Context ctx, Crypt::OpenSSL3::PKey pkey)
2915              
2916             bool SSL_CTX_use_PrivateKey_ASN1(Crypt::OpenSSL3::SSL::Context ctx, int pk, const unsigned char *d, long length(d))
2917             C_ARGS: pk, ctx, d, XSauto_length_of_d
2918              
2919             bool SSL_CTX_use_PrivateKey_file(Crypt::OpenSSL3::SSL::Context ctx, const char *file, int type)
2920              
2921             bool SSL_CTX_check_private_key(Crypt::OpenSSL3::SSL::Context ctx)
2922              
2923             void SSL_CTX_set_verify(Crypt::OpenSSL3::SSL::Context ctx, int mode)
2924             C_ARGS: ctx, mode, NULL
2925              
2926             void SSL_CTX_set_verify_depth(Crypt::OpenSSL3::SSL::Context ctx, int depth)
2927              
2928             void SSL_CTX_set_post_handshake_auth(Crypt::OpenSSL3::SSL::Context ctx, int val)
2929              
2930             bool SSL_CTX_set_cipher_list(Crypt::OpenSSL3::SSL::Context ctx, const char *str)
2931              
2932             bool SSL_CTX_set_ciphersuites(Crypt::OpenSSL3::SSL::Context ctx, const char *str)
2933              
2934             Crypt::OpenSSL3::X509::VerifyParam SSL_CTX_get_param(Crypt::OpenSSL3::SSL::Context ctx)
2935              
2936             bool SSL_CTX_set_param(Crypt::OpenSSL3::SSL::Context ctx, Crypt::OpenSSL3::X509::VerifyParam vpm);
2937              
2938             int SSL_CTX_add_client_CA(Crypt::OpenSSL3::SSL::Context ctx, Crypt::OpenSSL3::X509 cacert)
2939             POSTCALL:
2940 0           X509_up_ref(cacert);
2941              
2942             bool SSL_CTX_add_session(Crypt::OpenSSL3::SSL::Context ctx, Crypt::OpenSSL3::SSL::Session c);
2943              
2944             bool SSL_CTX_remove_session(Crypt::OpenSSL3::SSL::Context ctx, Crypt::OpenSSL3::SSL::Session c);
2945              
2946             long SSL_CTX_sess_number(Crypt::OpenSSL3::SSL::Context ctx)
2947              
2948             long SSL_CTX_sess_connect(Crypt::OpenSSL3::SSL::Context ctx)
2949              
2950             long SSL_CTX_sess_connect_good(Crypt::OpenSSL3::SSL::Context ctx)
2951              
2952             long SSL_CTX_sess_connect_renegotiate(Crypt::OpenSSL3::SSL::Context ctx)
2953              
2954             long SSL_CTX_sess_accept(Crypt::OpenSSL3::SSL::Context ctx)
2955              
2956             long SSL_CTX_sess_accept_good(Crypt::OpenSSL3::SSL::Context ctx)
2957              
2958             long SSL_CTX_sess_accept_renegotiate(Crypt::OpenSSL3::SSL::Context ctx)
2959              
2960             long SSL_CTX_sess_hits(Crypt::OpenSSL3::SSL::Context ctx)
2961              
2962             long SSL_CTX_sess_cb_hits(Crypt::OpenSSL3::SSL::Context ctx)
2963              
2964             long SSL_CTX_sess_misses(Crypt::OpenSSL3::SSL::Context ctx)
2965              
2966             long SSL_CTX_sess_timeouts(Crypt::OpenSSL3::SSL::Context ctx)
2967              
2968             long SSL_CTX_sess_cache_full(Crypt::OpenSSL3::SSL::Context ctx)
2969              
2970             long SSL_CTX_sess_set_cache_size(Crypt::OpenSSL3::SSL::Context ctx, long t)
2971              
2972             long SSL_CTX_sess_get_cache_size(Crypt::OpenSSL3::SSL::Context ctx)
2973              
2974             int SSL_CTX_set_num_tickets(Crypt::OpenSSL3::SSL::Context ctx, size_t num_tickets)
2975              
2976             size_t SSL_CTX_get_num_tickets(Crypt::OpenSSL3::SSL::Context ctx)
2977              
2978             #if OPENSSL_VERSION_PREREQ(3, 5)
2979              
2980             bool SSL_CTX_set_domain_flags(Crypt::OpenSSL3::SSL::Context ctx, uint64_t flags)
2981              
2982             NO_OUTPUT bool SSL_CTX_get_domain_flags(Crypt::OpenSSL3::SSL::Context ctx, OUTLIST uint64_t flags)
2983             POSTCALL:
2984             if (!RETVAL)
2985             XSRETURN_UNDEF;
2986             #endif
2987              
2988             MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::SSL PREFIX = SSL_
2989              
2990             BOOT:
2991             {
2992 62           HV* stash = gv_stashpvs("Crypt::OpenSSL3::SSL", GV_ADD | GV_ADDMULTI);
2993 62           CONSTANT2(SSL_, ERROR_NONE);
2994 62           CONSTANT2(SSL_, ERROR_ZERO_RETURN);
2995 62           CONSTANT2(SSL_, ERROR_WANT_READ);
2996 62           CONSTANT2(SSL_, ERROR_WANT_WRITE);
2997 62           CONSTANT2(SSL_, ERROR_WANT_CONNECT);
2998 62           CONSTANT2(SSL_, ERROR_WANT_ACCEPT);
2999 62           CONSTANT2(SSL_, ERROR_WANT_X509_LOOKUP);
3000 62           CONSTANT2(SSL_, ERROR_WANT_ASYNC);
3001 62           CONSTANT2(SSL_, ERROR_WANT_ASYNC_JOB);
3002 62           CONSTANT2(SSL_, ERROR_SYSCALL);
3003 62           CONSTANT2(SSL_, ERROR_SSL);
3004              
3005 62           CONSTANT2(SSL_, VERIFY_NONE);
3006 62           CONSTANT2(SSL_, VERIFY_PEER);
3007 62           CONSTANT2(SSL_, VERIFY_FAIL_IF_NO_PEER_CERT);
3008 62           CONSTANT2(SSL_, VERIFY_CLIENT_ONCE);
3009 62           CONSTANT2(SSL_, VERIFY_POST_HANDSHAKE);
3010              
3011 62           CONSTANT2(SSL_, MODE_ENABLE_PARTIAL_WRITE);
3012 62           CONSTANT2(SSL_, MODE_ACCEPT_MOVING_WRITE_BUFFER);
3013 62           CONSTANT2(SSL_, MODE_AUTO_RETRY);
3014 62           CONSTANT2(SSL_, MODE_RELEASE_BUFFERS);
3015 62           CONSTANT2(SSL_, MODE_SEND_FALLBACK_SCSV);
3016 62           CONSTANT2(SSL_, MODE_ASYNC);
3017              
3018 62           CONSTANT2(SSL_, FILETYPE_PEM);
3019 62           CONSTANT2(SSL_, FILETYPE_ASN1);
3020              
3021 62           CONSTANT2(, TLS1_VERSION);
3022 62           CONSTANT2(, TLS1_1_VERSION);
3023 62           CONSTANT2(, TLS1_2_VERSION);
3024 62           CONSTANT2(, TLS1_3_VERSION);
3025 62           CONSTANT2(, DTLS1_VERSION);
3026 62           CONSTANT2(, DTLS1_2_VERSION);
3027             #if OPENSSL_VERSION_PREREQ(3, 2)
3028             CONSTANT2(OSSL_, QUIC1_VERSION);
3029             CONSTANT2(SSL_, ACCEPT_STREAM_NO_BLOCK);
3030             CONSTANT2(SSL_, INCOMING_STREAM_POLICY_AUTO);
3031             CONSTANT2(SSL_, INCOMING_STREAM_POLICY_ACCEPT);
3032             CONSTANT2(SSL_, INCOMING_STREAM_POLICY_REJECT);
3033             CONSTANT2(SSL_, STREAM_FLAG_UNI);
3034             CONSTANT2(SSL_, STREAM_FLAG_NO_BLOCK);
3035             CONSTANT2(SSL_, STREAM_FLAG_ADVANCE);
3036             CONSTANT2(SSL_, STREAM_TYPE_NONE);
3037             CONSTANT2(SSL_, STREAM_TYPE_BIDI);
3038             CONSTANT2(SSL_, STREAM_TYPE_READ);
3039             CONSTANT2(SSL_, STREAM_TYPE_WRITE);
3040             #endif
3041             #if OPENSSL_VERSION_PREREQ(3, 5)
3042             CONSTANT2(SSL_, ACCEPT_CONNECTION_NO_BLOCK);
3043             CONSTANT2(SSL_, DOMAIN_FLAG_SINGLE_THREAD);
3044             CONSTANT2(SSL_, DOMAIN_FLAG_MULTI_THREAD);
3045             CONSTANT2(SSL_, DOMAIN_FLAG_THREAD_ASSISTED);
3046             CONSTANT2(SSL_, DOMAIN_FLAG_BLOCKING);
3047             CONSTANT2(SSL_, DOMAIN_FLAG_LEGACY_BLOCKING);
3048             #endif
3049             }
3050              
3051             Crypt::OpenSSL3::SSL SSL_new(classname, Crypt::OpenSSL3::SSL::Context context)
3052             C_ARGS: context
3053              
3054             Crypt::OpenSSL3::SSL::Method SSL_get_ssl_method(Crypt::OpenSSL3::SSL ssl)
3055              
3056             Crypt::OpenSSL3::SSL::Context SSL_get_context(Crypt::OpenSSL3::SSL ssl)
3057             POSTCALL:
3058 0           SSL_CTX_up_ref(RETVAL);
3059              
3060             NO_OUTPUT int SSL_get_event_timeout(Crypt::OpenSSL3::SSL s, OUTLIST struct timeval tv, OUTLIST Bool is_infinite)
3061             INIT:
3062 0           is_infinite = 0;
3063             POSTCALL:
3064 0 0         if (!RETVAL)
3065 0           XSRETURN_EMPTY;
3066              
3067             bool SSL_handle_events(Crypt::OpenSSL3::SSL ssl)
3068              
3069             long SSL_set_options(Crypt::OpenSSL3::SSL ssl, long options)
3070              
3071             long SSL_clear_options(Crypt::OpenSSL3::SSL ssl, long options)
3072              
3073             long SSL_get_options(Crypt::OpenSSL3::SSL ssl)
3074              
3075             bool SSL_set_session_id_context(Crypt::OpenSSL3::SSL ssl, const unsigned char *sid_ctx, unsigned int length(sid_ctx))
3076              
3077             long SSL_set_mode(Crypt::OpenSSL3::SSL ssl, long mode)
3078              
3079             long SSL_clear_mode(Crypt::OpenSSL3::SSL ssl, long mode)
3080              
3081             long SSL_get_mode(Crypt::OpenSSL3::SSL ssl)
3082              
3083             bool SSL_set_min_proto_version(Crypt::OpenSSL3::SSL ssl, int version)
3084              
3085             bool SSL_set_max_proto_version(Crypt::OpenSSL3::SSL ssl, int version)
3086              
3087             int SSL_get_min_proto_version(Crypt::OpenSSL3::SSL ssl)
3088              
3089             int SSL_get_max_proto_version(Crypt::OpenSSL3::SSL ssl)
3090              
3091             void SSL_set_security_level(Crypt::OpenSSL3::SSL s, int level)
3092              
3093             int SSL_get_security_level(Crypt::OpenSSL3::SSL s)
3094              
3095             bool SSL_set_alpn_protos(Crypt::OpenSSL3::SSL ssl, ...)
3096             CODE:
3097 0           SV* buffer = sv_2mortal(newSVpvs(""));
3098             static const char pattern[] = "(C/a)*";
3099 0           packlist(buffer, pattern, pattern + sizeof pattern - 1, &ST(1), &ST(items));
3100             STRLEN raw_len;
3101 0           const char* raw = SvPVbyte(buffer, raw_len);
3102 0 0         RETVAL = SSL_set_alpn_protos(ssl, (unsigned char*)raw, raw_len);
3103             OUTPUT: RETVAL
3104              
3105             bool SSL_use_certificate(Crypt::OpenSSL3::SSL ssl, Crypt::OpenSSL3::X509 x)
3106              
3107             bool SSL_use_certificate_ASN1(Crypt::OpenSSL3::SSL ssl, const unsigned char *d, int length(d))
3108              
3109             bool SSL_use_certificate_file(Crypt::OpenSSL3::SSL ssl, const char *file, int type)
3110              
3111             bool SSL_use_certificate_chain_file(Crypt::OpenSSL3::SSL ssl, const char *file)
3112              
3113             bool SSL_use_PrivateKey(Crypt::OpenSSL3::SSL ssl, Crypt::OpenSSL3::PKey pkey)
3114              
3115             bool SSL_use_PrivateKey_ASN1(Crypt::OpenSSL3::SSL ssl, int pk, const unsigned char *d, long length(d))
3116             C_ARGS: pk, ssl, d, XSauto_length_of_d
3117              
3118             bool SSL_use_PrivateKey_file(Crypt::OpenSSL3::SSL ssl, const char *file, int type)
3119              
3120             bool SSL_check_private_key(Crypt::OpenSSL3::SSL ssl)
3121              
3122             void SSL_set_verify(Crypt::OpenSSL3::SSL ssl, int mode)
3123             C_ARGS: ssl, mode, NULL
3124              
3125             void SSL_set_verify_depth(Crypt::OpenSSL3::SSL ssl, int depth)
3126              
3127             Crypt::OpenSSL3::X509::VerifyResult SSL_get_verify_result(Crypt::OpenSSL3::SSL ssl);
3128              
3129             void SSL_set_post_handshake_auth(Crypt::OpenSSL3::SSL ssl, int val)
3130              
3131             bool SSL_set_cipher_list(Crypt::OpenSSL3::SSL ssl, const char *str)
3132              
3133             bool SSL_set_ciphersuites(Crypt::OpenSSL3::SSL ssl, const char *str)
3134              
3135             const char *SSL_get_cipher_list(Crypt::OpenSSL3::SSL ssl, int priority)
3136             POSTCALL:
3137 0 0         if (!RETVAL)
3138 0           XSRETURN_UNDEF;
3139              
3140             Crypt::OpenSSL3::X509::VerifyParam SSL_get_param(Crypt::OpenSSL3::SSL ssl)
3141              
3142             bool SSL_set_param(Crypt::OpenSSL3::SSL ssl, Crypt::OpenSSL3::X509::VerifyParam vpm);
3143              
3144             int SSL_add_client_CA(Crypt::OpenSSL3::SSL ssl, Crypt::OpenSSL3::X509 cacert)
3145             POSTCALL:
3146 0           X509_up_ref(cacert);
3147              
3148             bool SSL_verify_client_post_handshake(Crypt::OpenSSL3::SSL ssl)
3149              
3150             int SSL_get_error(Crypt::OpenSSL3::SSL ssl, int ret)
3151              
3152             bool SSL_set_tlsext_host_name(Crypt::OpenSSL3::SSL s, const char *name)
3153              
3154             const char* SSL_get_servername(Crypt::OpenSSL3::SSL s, int type)
3155              
3156             int SSL_get_servername_type(Crypt::OpenSSL3::SSL s)
3157              
3158             bool SSL_set_host(Crypt::OpenSSL3::SSL s, const char *hostname)
3159              
3160             #if OPENSSL_VERSION_PREREQ(4, 0)
3161             bool SSL_set_dnsname(Crypt::OpenSSL3::SSL s, const char *hostname)
3162              
3163             bool SSL_set_ipaddr(Crypt::OpenSSL3::SSL s, const char *hostname)
3164             #endif
3165              
3166             int SSL_connect(Crypt::OpenSSL3::SSL ssl)
3167              
3168             int SSL_accept(Crypt::OpenSSL3::SSL ssl)
3169              
3170             int SSL_clear(Crypt::OpenSSL3::SSL ssl)
3171              
3172             int SSL_do_handshake(Crypt::OpenSSL3::SSL ssl)
3173              
3174             void SSL_set_connect_state(Crypt::OpenSSL3::SSL ssl)
3175              
3176             void SSL_set_accept_state(Crypt::OpenSSL3::SSL ssl)
3177              
3178             bool SSL_is_server(Crypt::OpenSSL3::SSL ssl)
3179              
3180             int SSL_read(Crypt::OpenSSL3::SSL ssl, SV* buffer, size_t size)
3181             INTERFACE: SSL_read SSL_peek
3182             INIT:
3183 1           char* ptr = grow_buffer(buffer, size);
3184             C_ARGS: ssl, ptr, size
3185             POSTCALL:
3186 1 50         if (RETVAL > 0)
3187 1           set_buffer_length(buffer, RETVAL);
3188              
3189             int SSL_write(Crypt::OpenSSL3::SSL ssl, const char* buf, int length(buf))
3190              
3191             ssize_t SSL_sendfile(Crypt::OpenSSL3::SSL s, int fd, uint64_t offset, size_t size, int flags)
3192              
3193             int SSL_shutdown(Crypt::OpenSSL3::SSL ssl)
3194              
3195             bool SSL_set_fd(Crypt::OpenSSL3::SSL ssl, int fd)
3196              
3197             bool SSL_set_rfd(Crypt::OpenSSL3::SSL ssl, int fd)
3198              
3199             bool SSL_set_wfd(Crypt::OpenSSL3::SSL ssl, int fd)
3200              
3201             int SSL_get_fd(Crypt::OpenSSL3::SSL ssl)
3202              
3203             int SSL_get_rfd(Crypt::OpenSSL3::SSL ssl)
3204              
3205             int SSL_get_wfd(Crypt::OpenSSL3::SSL ssl)
3206              
3207             void SSL_set_rbio(Crypt::OpenSSL3::SSL s, Crypt::OpenSSL3::BIO bio)
3208             INTERFACE: SSL_set_rbio SSL_set_wbio
3209             INIT:
3210 4           BIO_up_ref(bio);
3211              
3212             Crypt::OpenSSL3::BIO SSL_get_rbio(Crypt::OpenSSL3::SSL ssl)
3213             INTERFACE: SSL_get_rbio SSL_get_wbio
3214             POSTCALL:
3215 0 0         if (RETVAL)
3216 0           BIO_up_ref(RETVAL);
3217             else
3218 0           XSRETURN_UNDEF;
3219              
3220             void SSL_set_read_ahead(Crypt::OpenSSL3::SSL s, bool yes)
3221              
3222             bool SSL_get_read_ahead(Crypt::OpenSSL3::SSL s)
3223              
3224             Crypt::OpenSSL3::SSL::Session SSL_get_session(Crypt::OpenSSL3::SSL ssl)
3225             POSTCALL:
3226 0 0         if (RETVAL)
3227 0           SSL_SESSION_up_ref(RETVAL);
3228             else
3229 0           XSRETURN_UNDEF;
3230              
3231             bool SSL_set_session(Crypt::OpenSSL3::SSL ssl, Crypt::OpenSSL3::SSL::Session session)
3232              
3233             bool SSL_session_reused(Crypt::OpenSSL3::SSL ssl)
3234              
3235             Crypt::OpenSSL3::X509 SSL_get_certificate(Crypt::OpenSSL3::SSL ssl)
3236             INTERFACE: SSL_get_certificate SSL_get_peer_certificate
3237             POSTCALL:
3238 0 0         if (RETVAL)
3239 0           X509_up_ref(RETVAL);
3240             else
3241 0           XSRETURN_UNDEF;
3242              
3243             Crypt::OpenSSL3::PKey SSL_get_privatekey(Crypt::OpenSSL3::SSL ssl)
3244             POSTCALL:
3245 0 0         if (RETVAL)
3246 0           EVP_PKEY_up_ref(RETVAL);
3247             else
3248 0           XSRETURN_UNDEF;
3249              
3250             Crypt::OpenSSL3::SSL::Cipher SSL_get_current_cipher(Crypt::OpenSSL3::SSL ssl)
3251             INTERFACE: SSL_get_current_cipher SSL_get_pending_cipher
3252             POSTCALL:
3253 0 0         if (!RETVAL)
3254 0           XSRETURN_UNDEF;
3255              
3256             int SSL_client_version(Crypt::OpenSSL3::SSL s)
3257              
3258             const char *SSL_get_version(Crypt::OpenSSL3::SSL ssl)
3259              
3260             bool SSL_is_dtls(Crypt::OpenSSL3::SSL ssl)
3261              
3262             bool SSL_is_tls(Crypt::OpenSSL3::SSL ssl)
3263              
3264             bool SSL_is_quic(Crypt::OpenSSL3::SSL ssl)
3265              
3266             bool SSL_in_init(Crypt::OpenSSL3::SSL s)
3267              
3268             bool SSL_in_before(Crypt::OpenSSL3::SSL s)
3269              
3270             bool SSL_is_init_finished(Crypt::OpenSSL3::SSL s)
3271              
3272             bool SSL_in_connect_init(Crypt::OpenSSL3::SSL s)
3273              
3274             bool SSL_in_accept_init(Crypt::OpenSSL3::SSL s)
3275              
3276             int SSL_pending(Crypt::OpenSSL3::SSL ssl)
3277              
3278             bool SSL_has_pending(Crypt::OpenSSL3::SSL s)
3279              
3280             int SSL_version(Crypt::OpenSSL3::SSL s)
3281              
3282             const char *SSL_state_string(Crypt::OpenSSL3::SSL ssl)
3283              
3284             const char *SSL_state_string_long(Crypt::OpenSSL3::SSL ssl)
3285              
3286             const char *SSL_rstate_string(Crypt::OpenSSL3::SSL ssl)
3287              
3288             const char *SSL_rstate_string_long(Crypt::OpenSSL3::SSL ssl)
3289              
3290             int SSL_set_num_tickets(Crypt::OpenSSL3::SSL s, size_t num_tickets)
3291              
3292             size_t SSL_get_num_tickets(Crypt::OpenSSL3::SSL s)
3293              
3294             bool SSL_new_session_ticket(Crypt::OpenSSL3::SSL s)
3295              
3296             NO_OUTPUT size_t SSL_get_finished(Crypt::OpenSSL3::SSL ssl, OUTLIST SV* result)
3297             size_t max_size = EVP_MAX_MD_SIZE;
3298             INTERFACE: SSL_get_finished SSL_get_peer_finished
3299             INIT:
3300 0           unsigned char* ptr = make_buffer(&result, max_size);
3301             C_ARGS: ssl, ptr, max_size
3302             POSTCALL:
3303 0 0         if (RETVAL)
3304 0           set_buffer_length(result, RETVAL);
3305              
3306             void SSL_get_alpn_selected(Crypt::OpenSSL3::SSL s, OUTLIST SV* result)
3307             const unsigned char* ptr = NULL;
3308             unsigned int len = 0;
3309             C_ARGS: s, &ptr, &len
3310             POSTCALL:
3311 0           result = newSVpvn((char*)ptr, len);
3312              
3313             #if OPENSSL_VERSION_PREREQ(3, 2)
3314              
3315             bool SSL_set_blocking_mode(Crypt::OpenSSL3::SSL s, int blocking)
3316              
3317             Success SSL_get_blocking_mode(Crypt::OpenSSL3::SSL s)
3318              
3319             Crypt::OpenSSL3::SSL SSL_new_stream(Crypt::OpenSSL3::SSL ssl, uint64_t flags)
3320              
3321             bool SSL_set_incoming_stream_policy(Crypt::OpenSSL3::SSL conn, int policy, uint64_t app_error_code = 0)
3322              
3323             Crypt::OpenSSL3::SSL SSL_accept_stream(Crypt::OpenSSL3::SSL ssl, uint64_t flags)
3324              
3325             size_t SSL_get_accept_stream_queue_len(Crypt::OpenSSL3::SSL ssl)
3326              
3327             bool SSL_set_default_stream_mode(Crypt::OpenSSL3::SSL conn, unsigned mode)
3328              
3329             bool SSL_stream_conclude(Crypt::OpenSSL3::SSL s, uint64_t flags)
3330              
3331             bool SSL_stream_reset(Crypt::OpenSSL3::SSL ssl)
3332             C_ARGS: ssl, NULL, 0
3333              
3334             int SSL_get_rpoll_descriptor(Crypt::OpenSSL3::SSL s, Crypt::OpenSSL3::BIO::PollDescriptor desc)
3335              
3336             int SSL_get_wpoll_descriptor(Crypt::OpenSSL3::SSL s, Crypt::OpenSSL3::BIO::PollDescriptor desc)
3337              
3338             bool SSL_net_read_desired(Crypt::OpenSSL3::SSL s)
3339              
3340             bool SSL_net_write_desired(Crypt::OpenSSL3::SSL s)
3341              
3342             Crypt::OpenSSL3::SSL SSL_get_connection(Crypt::OpenSSL3::SSL ssl)
3343             POSTCALL:
3344             SSL_up_ref(RETVAL);
3345              
3346             bool SSL_is_connection(Crypt::OpenSSL3::SSL ssl)
3347              
3348             uint64_t SSL_get_stream_id(Crypt::OpenSSL3::SSL ssl)
3349             POSTCALL:
3350             if (RETVAL == UINT64_MAX)
3351             XSRETURN_UNDEF;
3352              
3353             int SSL_get_stream_type(Crypt::OpenSSL3::SSL ssl)
3354              
3355             Success SSL_is_stream_local(Crypt::OpenSSL3::SSL ssl)
3356              
3357             bool SSL_set_initial_peer_addr(Crypt::OpenSSL3::SSL s, Crypt::OpenSSL3::BIO::Address addr)
3358              
3359             #endif
3360              
3361              
3362             #if OPENSSL_VERSION_PREREQ(3, 5)
3363              
3364             Crypt::OpenSSL3::SSL SSL_new_listener(classname, Crypt::OpenSSL3::SSL::Context ctx, uint64_t flags)
3365             C_ARGS: ctx, flags
3366              
3367             Crypt::OpenSSL3::SSL SSL_new_listener_from(Crypt::OpenSSL3::SSL ssl, uint64_t flags)
3368              
3369             bool SSL_is_listener(Crypt::OpenSSL3::SSL ssl)
3370              
3371             Crypt::OpenSSL3::SSL SSL_get_listener(Crypt::OpenSSL3::SSL ssl)
3372             INTERFACE: SSL_get_listener SSL_get_domain
3373             POSTCALL:
3374             if (RETVAL)
3375             SSL_up_ref(RETVAL);
3376             else
3377             XSRETURN_UNDEF;
3378              
3379             bool SSL_listen(Crypt::OpenSSL3::SSL ssl)
3380              
3381             Crypt::OpenSSL3::SSL SSL_accept_connection(Crypt::OpenSSL3::SSL ssl, uint64_t flags)
3382              
3383             size_t SSL_get_accept_connection_queue_len(Crypt::OpenSSL3::SSL ssl)
3384              
3385             Crypt::OpenSSL3::SSL SSL_new_from_listener(Crypt::OpenSSL3::SSL ssl, uint64_t flags)
3386              
3387             Crypt::OpenSSL3::SSL SSL_new_domain(Crypt::OpenSSL3::SSL::Context ctx, uint64_t flags)
3388              
3389             bool SSL_is_domain(Crypt::OpenSSL3::SSL ssl)
3390              
3391             NO_OUTPUT int SSL_get_domain_flags(Crypt::OpenSSL3::SSL ssl, OUTLIST uint64_t flags)
3392             POSTCALL:
3393             if (!RETVAL)
3394             XSRETURN_UNDEF;
3395              
3396             #endif
3397              
3398              
3399             MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::SSL::Cipher PREFIX = SSL_CIPHER_
3400              
3401             const char *SSL_CIPHER_get_name(Crypt::OpenSSL3::SSL::Cipher cipher)
3402              
3403             const char *SSL_CIPHER_standard_name(Crypt::OpenSSL3::SSL::Cipher cipher)
3404              
3405             NO_OUTPUT int SSL_CIPHER_get_bits(Crypt::OpenSSL3::SSL::Cipher cipher, OUTLIST int alg_bits)
3406             POSTCALL:
3407 0 0         if (!RETVAL)
3408 0           alg_bits = 0;
3409              
3410             const char *SSL_CIPHER_get_version(Crypt::OpenSSL3::SSL::Cipher cipher)
3411              
3412             NO_OUTPUT char *SSL_CIPHER_description(Crypt::OpenSSL3::SSL::Cipher cipher, OUTLIST SV* description, int length = 128)
3413             INIT:
3414 0           char* ptr = (char*)make_buffer(&description, length);
3415             C_ARGS: cipher, ptr, length
3416             POSTCALL:
3417 0 0         if (RETVAL)
3418 0           set_buffer_length(description, strlen(ptr));
3419              
3420             Crypt::OpenSSL3::NID SSL_CIPHER_get_cipher_nid(Crypt::OpenSSL3::SSL::Cipher c)
3421              
3422             Crypt::OpenSSL3::NID SSL_CIPHER_get_digest_nid(Crypt::OpenSSL3::SSL::Cipher c)
3423              
3424             Crypt::OpenSSL3::MD SSL_CIPHER_get_handshake_digest(Crypt::OpenSSL3::SSL::Cipher c)
3425             POSTCALL:
3426 0 0         if (RETVAL)
3427 0           EVP_MD_up_ref(RETVAL);
3428             else
3429 0           XSRETURN_UNDEF;
3430              
3431             Crypt::OpenSSL3::NID SSL_CIPHER_get_kx_nid(Crypt::OpenSSL3::SSL::Cipher c)
3432              
3433             Crypt::OpenSSL3::NID SSL_CIPHER_get_auth_nid(Crypt::OpenSSL3::SSL::Cipher c)
3434              
3435             bool SSL_CIPHER_is_aead(Crypt::OpenSSL3::SSL::Cipher c)
3436              
3437             unsigned SSL_CIPHER_get_id(Crypt::OpenSSL3::SSL::Cipher c)
3438              
3439             unsigned SSL_CIPHER_get_protocol_id(Crypt::OpenSSL3::SSL::Cipher c)
3440              
3441              
3442              
3443             MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::SSL::Session PREFIX = SSL_SESSION_
3444              
3445             Crypt::OpenSSL3::SSL::Session SSL_SESSION_new(class)
3446             C_ARGS:
3447              
3448             Crypt::OpenSSL3::SSL::Session SSL_SESSION_read_der(class, Crypt::OpenSSL3::BIO bio)
3449             C_ARGS: bio, NULL
3450             POSTCALL:
3451 0 0         if (!RETVAL)
3452 0           XSRETURN_UNDEF;
3453              
3454             bool SSL_SESSION_write_der(Crypt::OpenSSL3::SSL::Session x, Crypt::OpenSSL3::BIO bio)
3455             C_ARGS: bio, x
3456              
3457             Crypt::OpenSSL3::SSL::Session SSL_SESSION_dup(Crypt::OpenSSL3::SSL::Session s)
3458              
3459             long SSL_SESSION_get_timeout(Crypt::OpenSSL3::SSL::Session s)
3460              
3461             long SSL_SESSION_set_timeout(Crypt::OpenSSL3::SSL::Session s, long t)
3462              
3463             int SSL_SESSION_get_protocol_version(Crypt::OpenSSL3::SSL::Session s)
3464              
3465             int SSL_SESSION_set_protocol_version(Crypt::OpenSSL3::SSL::Session s, int version)
3466              
3467             time_t SSL_SESSION_get_time(Crypt::OpenSSL3::SSL::Session s)
3468              
3469             time_t SSL_SESSION_set_time(Crypt::OpenSSL3::SSL::Session s, time_t t)
3470              
3471             const char *SSL_SESSION_get_hostname(Crypt::OpenSSL3::SSL::Session s)
3472              
3473             bool SSL_SESSION_set_hostname(Crypt::OpenSSL3::SSL::Session s, const char *hostname)
3474              
3475             void SSL_SESSION_get_alpn_selected(Crypt::OpenSSL3::SSL::Session s, OUTLIST SV* result)
3476             const unsigned char* ptr = NULL;
3477             size_t len = 0;
3478             C_ARGS: s, &ptr, &len
3479             POSTCALL:
3480 0           result = newSVpvn((char*)ptr, len);
3481              
3482             bool SSL_SESSION_set_alpn_selected(Crypt::OpenSSL3::SSL::Session s, const unsigned char *alpn, size_t length(alpn))
3483              
3484             Crypt::OpenSSL3::SSL::Cipher SSL_SESSION_get_cipher(Crypt::OpenSSL3::SSL::Session s)
3485              
3486             bool SSL_SESSION_set_cipher(Crypt::OpenSSL3::SSL::Session s, Crypt::OpenSSL3::SSL::Cipher cipher)
3487              
3488             bool SSL_SESSION_has_ticket(Crypt::OpenSSL3::SSL::Session s)
3489              
3490             unsigned long SSL_SESSION_get_ticket_lifetime_hint(Crypt::OpenSSL3::SSL::Session s)
3491              
3492             void SSL_SESSION_get_ticket(Crypt::OpenSSL3::SSL::Session s, OUTLIST SV* result)
3493             const unsigned char* ptr = NULL;
3494             size_t len = 0;
3495             C_ARGS: s, &ptr, &len
3496             POSTCALL:
3497 0           result = newSVpvn((char*)ptr, len);
3498              
3499             unsigned SSL_SESSION_get_max_early_data(Crypt::OpenSSL3::SSL::Session s)
3500              
3501             bool SSL_SESSION_set_max_early_data(Crypt::OpenSSL3::SSL::Session s, unsigned max_early_data)
3502              
3503             Crypt::OpenSSL3::X509 SSL_SESSION_get_peer(Crypt::OpenSSL3::SSL::Session session)
3504             POSTCALL:
3505 0 0         if (RETVAL)
3506 0           X509_up_ref(RETVAL);
3507             else
3508 0           XSRETURN_UNDEF;
3509              
3510             bool SSL_SESSION_set_id_context(Crypt::OpenSSL3::SSL::Session s, const unsigned char *sid_ctx, unsigned int length(sid_ctx))
3511              
3512             bool SSL_SESSION_set_id(Crypt::OpenSSL3::SSL::Session s, const unsigned char *sid, unsigned int length(sid))
3513              
3514             bool SSL_SESSION_is_resumable(Crypt::OpenSSL3::SSL::Session s)
3515              
3516             NO_OUTPUT const unsigned char *SSL_SESSION_get_id(Crypt::OpenSSL3::SSL::Session s, OUTLIST SV* result)
3517             INTERFACE: SSL_SESSION_get_id SSL_SESSION_get_id_context
3518             INIT:
3519 0           unsigned int len = 0;
3520             C_ARGS: s, &len
3521             POSTCALL:
3522 0           result = newSVpvn((char*)RETVAL, len);
3523              
3524             unsigned int SSL_SESSION_get_compress_id(Crypt::OpenSSL3::SSL::Session s)
3525              
3526             bool SSL_SESSION_print(Crypt::OpenSSL3::SSL::Session ses, Crypt::OpenSSL3::BIO fp)
3527             C_ARGS: fp, ses
3528              
3529             bool SSL_SESSION_print_keylog(Crypt::OpenSSL3::SSL::Session ses, Crypt::OpenSSL3::BIO bp)
3530             C_ARGS: bp, ses
3531              
3532             Crypt::OpenSSL3::SSL::Session SSL_SESSION_decode_der(class, ASN1_DECODER* buffer)
3533             CODE:
3534 0           RETVAL = d2i_SSL_SESSION(NULL, &buffer->ptr, buffer->end - buffer->ptr);
3535 0 0         if (!RETVAL)
3536 0           XSRETURN_UNDEF;
3537             OUTPUT: RETVAL
3538              
3539             SV* SSL_SESSION_encode_der(Crypt::OpenSSL3::SSL::Session x)
3540             CODE:
3541 0           int length = i2d_SSL_SESSION(x, NULL);
3542 0 0         if (length > 0) {
3543 0           unsigned char* ptr = make_buffer(&RETVAL, length);
3544 0           i2d_SSL_SESSION(x, &ptr);
3545 0           set_buffer_length(RETVAL, length);
3546             } else
3547 0           RETVAL = &PL_sv_undef;
3548             OUTPUT: RETVAL
3549              
3550              
3551             MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::Timestamp::Request PREFIX = TS_REQ_
3552              
3553             Crypt::OpenSSL3::Timestamp::Request TS_REQ_new(class)
3554             C_ARGS:
3555              
3556             bool TS_REQ_set_version(Crypt::OpenSSL3::Timestamp::Request a, long version)
3557              
3558             long TS_REQ_get_version(Crypt::OpenSSL3::Timestamp::Request a)
3559              
3560             bool TS_REQ_set_msg_imprint(Crypt::OpenSSL3::Timestamp::Request a, Crypt::OpenSSL3::Timestamp::Imprint msg_imprint)
3561             C_ARGS: a, TS_MSG_IMPRINT_dup(msg_imprint)
3562              
3563             Crypt::OpenSSL3::Timestamp::Imprint TS_REQ_get_msg_imprint(Crypt::OpenSSL3::Timestamp::Request a)
3564             POSTCALL:
3565 0 0         if (RETVAL)
3566 0           RETVAL = TS_MSG_IMPRINT_dup(RETVAL);
3567             else
3568 0           XSRETURN_UNDEF;
3569              
3570             bool TS_REQ_set_policy_id(Crypt::OpenSSL3::Timestamp::Request a, Crypt::OpenSSL3::ASN1::Object policy)
3571             C_ARGS: a, ASN1_OBJECT_dup(policy)
3572              
3573             Crypt::OpenSSL3::ASN1::Object TS_REQ_get_policy_id(Crypt::OpenSSL3::Timestamp::Request a)
3574             POSTCALL:
3575 0 0         if (RETVAL)
3576 0           RETVAL = ASN1_OBJECT_dup(RETVAL);
3577             else
3578 0           XSRETURN_UNDEF;
3579              
3580             bool TS_REQ_set_nonce(Crypt::OpenSSL3::Timestamp::Request a, ASN1_INTEGER* nonce)
3581              
3582             const ASN1_INTEGER* TS_REQ_get_nonce(Crypt::OpenSSL3::Timestamp::Request a)
3583             POSTCALL:
3584 0 0         if (!RETVAL)
3585 0           XSRETURN_UNDEF;
3586              
3587             bool TS_REQ_set_cert_req(Crypt::OpenSSL3::Timestamp::Request a, int cert_req)
3588              
3589             int TS_REQ_get_cert_req(Crypt::OpenSSL3::Timestamp::Request a)
3590              
3591             void TS_REQ_get_exts(Crypt::OpenSSL3::Timestamp::Request a)
3592             PPCODE:
3593 0           STACK_OF(X509_EXTENSION)* exts = TS_REQ_get_exts(a);
3594 0 0         CSTACK_TO_STACK(X509_EXTENSION, exts);
    0          
    0          
    0          
3595              
3596             int TS_REQ_get_ext_count(Crypt::OpenSSL3::Timestamp::Request a)
3597              
3598             int TS_REQ_get_ext_by_NID(Crypt::OpenSSL3::Timestamp::Request a, Crypt::OpenSSL3::NID nid, int lastpos = -1)
3599             POSTCALL:
3600 0 0         if (RETVAL == -1)
3601 0           XSRETURN_UNDEF;
3602              
3603             int TS_REQ_get_ext_by_OBJ(Crypt::OpenSSL3::Timestamp::Request a, Crypt::OpenSSL3::ASN1::Object obj, int lastpos = -1)
3604             POSTCALL:
3605 0 0         if (RETVAL == -1)
3606 0           XSRETURN_UNDEF;
3607              
3608             int TS_REQ_get_ext_by_critical(Crypt::OpenSSL3::Timestamp::Request a, int crit, int lastpos = -1)
3609             POSTCALL:
3610 0 0         if (RETVAL == -1)
3611 0           XSRETURN_UNDEF;
3612              
3613             Crypt::OpenSSL3::X509::Extension TS_REQ_get_ext(Crypt::OpenSSL3::Timestamp::Request a, int loc)
3614             POSTCALL:
3615 0 0         if (RETVAL)
3616 0           RETVAL = X509_EXTENSION_dup(RETVAL);
3617             else
3618 0           XSRETURN_UNDEF;
3619              
3620             Crypt::OpenSSL3::X509::Extension TS_REQ_delete_ext(Crypt::OpenSSL3::Timestamp::Request a, int loc)
3621             POSTCALL:
3622 0 0         if (!RETVAL)
3623 0           XSRETURN_UNDEF;
3624              
3625             bool TS_REQ_add_ext(Crypt::OpenSSL3::Timestamp::Request a, Crypt::OpenSSL3::X509::Extension ex, int loc)
3626             C_ARGS: a, X509_EXTENSION_dup(ex), loc
3627              
3628             PrintRet TS_REQ_print(Crypt::OpenSSL3::Timestamp::Request a, Crypt::OpenSSL3::BIO bio)
3629              
3630             Crypt::OpenSSL3::Timestamp::Request TS_REQ_read_der(class, Crypt::OpenSSL3::BIO bio)
3631             C_ARGS: bio, NULL
3632             POSTCALL:
3633 0 0         if (!RETVAL)
3634 0           XSRETURN_UNDEF;
3635              
3636             bool TS_REQ_write_der(Crypt::OpenSSL3::Timestamp::Request x, Crypt::OpenSSL3::BIO bio)
3637             C_ARGS: bio, x
3638              
3639             Crypt::OpenSSL3::Timestamp::Request TS_REQ_decode_der(class, ASN1_DECODER* buffer)
3640             CODE:
3641 0           RETVAL = d2i_TS_REQ(NULL, &buffer->ptr, buffer->end - buffer->ptr);
3642 0 0         if (!RETVAL)
3643 0           XSRETURN_UNDEF;
3644             OUTPUT: RETVAL
3645              
3646             SV* TS_REQ_encode_der(Crypt::OpenSSL3::Timestamp::Request x)
3647             CODE:
3648 0           int length = i2d_TS_REQ(x, NULL);
3649 0 0         if (length > 0) {
3650 0           unsigned char* ptr = make_buffer(&RETVAL, length);
3651 0           i2d_TS_REQ(x, &ptr);
3652 0           set_buffer_length(RETVAL, length);
3653             } else
3654 0           RETVAL = &PL_sv_undef;
3655             OUTPUT: RETVAL
3656              
3657              
3658             MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::Timestamp::Imprint PREFIX = TS_MSG_IMPRINT_
3659              
3660             Crypt::OpenSSL3::Timestamp::Imprint TS_MSG_IMPRINT_new(class)
3661             C_ARGS:
3662              
3663             bool TS_MSG_IMPRINT_set_algo(Crypt::OpenSSL3::Timestamp::Imprint a, Crypt::OpenSSL3::X509::Algorithm alg)
3664             C_ARGS: a, X509_ALGOR_dup(alg)
3665              
3666             Crypt::OpenSSL3::X509::Algorithm TS_MSG_IMPRINT_get_algo(Crypt::OpenSSL3::Timestamp::Imprint a)
3667             POSTCALL:
3668 0           RETVAL = X509_ALGOR_dup(RETVAL);
3669              
3670             bool TS_MSG_IMPRINT_set_msg(Crypt::OpenSSL3::Timestamp::Imprint a, unsigned char *d, int length(d))
3671             C_ARGS: a, OPENSSL_memdup(d, XSauto_length_of_d), XSauto_length_of_d
3672              
3673             ASN1_OCTET_STRING* TS_MSG_IMPRINT_get_msg(Crypt::OpenSSL3::Timestamp::Imprint a)
3674              
3675             PrintRet TS_MSG_IMPRINT_print(Crypt::OpenSSL3::Timestamp::Imprint a, Crypt::OpenSSL3::BIO bio)
3676              
3677             Crypt::OpenSSL3::Timestamp::Imprint TS_MSG_IMPRINT_read_der(class, Crypt::OpenSSL3::BIO bio)
3678             C_ARGS: bio, NULL
3679             POSTCALL:
3680 0 0         if (!RETVAL)
3681 0           XSRETURN_UNDEF;
3682              
3683             bool TS_MSG_IMPRINT_write_der(Crypt::OpenSSL3::Timestamp::Imprint x, Crypt::OpenSSL3::BIO bio)
3684             C_ARGS: bio, x
3685              
3686             Crypt::OpenSSL3::Timestamp::Imprint TS_MSG_IMPRINT_decode_der(class, ASN1_DECODER* buffer)
3687             CODE:
3688 0           RETVAL = d2i_TS_MSG_IMPRINT(NULL, &buffer->ptr, buffer->end - buffer->ptr);
3689 0 0         if (!RETVAL)
3690 0           XSRETURN_UNDEF;
3691             OUTPUT: RETVAL
3692              
3693             SV* TS_MSG_IMPRINT_encode_der(Crypt::OpenSSL3::Timestamp::Imprint x)
3694             CODE:
3695 0           int length = i2d_TS_MSG_IMPRINT(x, NULL);
3696 0 0         if (length > 0) {
3697 0           unsigned char* ptr = make_buffer(&RETVAL, length);
3698 0           i2d_TS_MSG_IMPRINT(x, &ptr);
3699 0           set_buffer_length(RETVAL, length);
3700             } else
3701 0           RETVAL = &PL_sv_undef;
3702             OUTPUT: RETVAL
3703              
3704              
3705             MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::Timestamp::TokenInfo PREFIX = TS_TST_INFO_
3706              
3707             Crypt::OpenSSL3::Timestamp::TokenInfo TS_TST_INFO_new(class)
3708             C_ARGS:
3709              
3710             bool TS_TST_INFO_set_version(Crypt::OpenSSL3::Timestamp::TokenInfo a, long version)
3711              
3712             long TS_TST_INFO_get_version(Crypt::OpenSSL3::Timestamp::TokenInfo a)
3713              
3714             bool TS_TST_INFO_set_policy_id(Crypt::OpenSSL3::Timestamp::TokenInfo a, Crypt::OpenSSL3::ASN1::Object policy_id)
3715             C_ARGS: a, ASN1_OBJECT_dup(policy_id)
3716              
3717             Crypt::OpenSSL3::ASN1::Object TS_TST_INFO_get_policy_id(Crypt::OpenSSL3::Timestamp::TokenInfo a)
3718             POSTCALL:
3719 0 0         if (RETVAL)
3720 0           RETVAL = ASN1_OBJECT_dup(RETVAL);
3721             else
3722 0           XSRETURN_UNDEF;
3723              
3724             bool TS_TST_INFO_set_msg_imprint(Crypt::OpenSSL3::Timestamp::TokenInfo a, Crypt::OpenSSL3::Timestamp::Imprint msg_imprint)
3725              
3726             Crypt::OpenSSL3::Timestamp::Imprint TS_TST_INFO_get_msg_imprint(Crypt::OpenSSL3::Timestamp::TokenInfo a)
3727             POSTCALL:
3728 0           RETVAL = TS_MSG_IMPRINT_dup(RETVAL);
3729              
3730             bool TS_TST_INFO_set_serial(Crypt::OpenSSL3::Timestamp::TokenInfo a, ASN1_INTEGER* serial)
3731             INTERFACE: TS_TST_INFO_set_serial TS_TST_INFO_set_nonce
3732              
3733             const ASN1_INTEGER* TS_TST_INFO_get_serial(Crypt::OpenSSL3::Timestamp::TokenInfo a)
3734             INTERFACE: TS_TST_INFO_get_serial TS_TST_INFO_get_nonce
3735             POSTCALL:
3736 0 0         if (!RETVAL)
3737 0           XSRETURN_UNDEF;
3738              
3739             bool TS_TST_INFO_set_time(Crypt::OpenSSL3::Timestamp::TokenInfo a, const ASN1_GENERALIZEDTIME* gtime)
3740              
3741             const ASN1_GENERALIZEDTIME* TS_TST_INFO_get_time(Crypt::OpenSSL3::Timestamp::TokenInfo a)
3742              
3743             bool TS_TST_INFO_set_accuracy(Crypt::OpenSSL3::Timestamp::TokenInfo a, Crypt::OpenSSL3::Timestamp::Accuracy accuracy)
3744              
3745             Crypt::OpenSSL3::Timestamp::Accuracy TS_TST_INFO_get_accuracy(Crypt::OpenSSL3::Timestamp::TokenInfo a)
3746             POSTCALL:
3747 0 0         if (RETVAL)
3748 0           RETVAL = TS_ACCURACY_dup(RETVAL);
3749             else
3750 0           XSRETURN_UNDEF;
3751              
3752             bool TS_TST_INFO_set_ordering(Crypt::OpenSSL3::Timestamp::TokenInfo a, int ordering)
3753              
3754             int TS_TST_INFO_get_ordering(Crypt::OpenSSL3::Timestamp::TokenInfo a)
3755              
3756             bool TS_TST_INFO_set_tsa(Crypt::OpenSSL3::Timestamp::TokenInfo a, Crypt::OpenSSL3::X509::GeneralName tsa)
3757             C_ARGS: a, GENERAL_NAME_dup(tsa)
3758              
3759             Crypt::OpenSSL3::X509::GeneralName TS_TST_INFO_get_tsa(Crypt::OpenSSL3::Timestamp::TokenInfo a)
3760             POSTCALL:
3761 0 0         if (RETVAL)
3762 0           RETVAL = GENERAL_NAME_dup(RETVAL);
3763             else
3764 0           XSRETURN_UNDEF;
3765              
3766             int TS_TST_INFO_get_ext_count(Crypt::OpenSSL3::Timestamp::TokenInfo a)
3767              
3768             int TS_TST_INFO_get_ext_by_NID(Crypt::OpenSSL3::Timestamp::TokenInfo a, Crypt::OpenSSL3::NID nid, int lastpos = -1)
3769             POSTCALL:
3770 0 0         if (RETVAL == -1)
3771 0           XSRETURN_UNDEF;
3772              
3773             int TS_TST_INFO_get_ext_by_OBJ(Crypt::OpenSSL3::Timestamp::TokenInfo a, Crypt::OpenSSL3::ASN1::Object obj, int lastpos = -1)
3774             POSTCALL:
3775 0 0         if (RETVAL == -1)
3776 0           XSRETURN_UNDEF;
3777              
3778             int TS_TST_INFO_get_ext_by_critical(Crypt::OpenSSL3::Timestamp::TokenInfo a, int crit, int lastpos = -1)
3779             POSTCALL:
3780 0 0         if (RETVAL == -1)
3781 0           XSRETURN_UNDEF;
3782              
3783             Crypt::OpenSSL3::X509::Extension TS_TST_INFO_get_ext(Crypt::OpenSSL3::Timestamp::TokenInfo a, int loc)
3784             POSTCALL:
3785 0 0         if (RETVAL)
3786 0           RETVAL = X509_EXTENSION_dup(RETVAL);
3787             else
3788 0           XSRETURN_UNDEF;
3789              
3790             Crypt::OpenSSL3::X509::Extension TS_TST_INFO_delete_ext(Crypt::OpenSSL3::Timestamp::TokenInfo a, int loc)
3791             POSTCALL:
3792 0 0         if (!RETVAL)
3793 0           XSRETURN_UNDEF;
3794              
3795             bool TS_TST_INFO_add_ext(Crypt::OpenSSL3::Timestamp::TokenInfo a, Crypt::OpenSSL3::X509::Extension ex, int loc)
3796              
3797             PrintRet TS_TST_INFO_print(Crypt::OpenSSL3::Timestamp::TokenInfo a, Crypt::OpenSSL3::BIO bio)
3798              
3799             Crypt::OpenSSL3::Timestamp::TokenInfo TS_TST_INFO_read_der(class, Crypt::OpenSSL3::BIO bio)
3800             C_ARGS: bio, NULL
3801             POSTCALL:
3802 0 0         if (!RETVAL)
3803 0           XSRETURN_UNDEF;
3804              
3805             bool TS_TST_INFO_write_der(Crypt::OpenSSL3::Timestamp::TokenInfo x, Crypt::OpenSSL3::BIO bio)
3806             C_ARGS: bio, x
3807              
3808             Crypt::OpenSSL3::Timestamp::TokenInfo TS_TST_INFO_decode_der(class, ASN1_DECODER* buffer)
3809             CODE:
3810 0           RETVAL = d2i_TS_TST_INFO(NULL, &buffer->ptr, buffer->end - buffer->ptr);
3811 0 0         if (!RETVAL)
3812 0           XSRETURN_UNDEF;
3813             OUTPUT: RETVAL
3814              
3815             SV* TS_TST_INFO_encode_der(Crypt::OpenSSL3::Timestamp::TokenInfo x)
3816             CODE:
3817 0           int length = i2d_TS_TST_INFO(x, NULL);
3818 0 0         if (length > 0) {
3819 0           unsigned char* ptr = make_buffer(&RETVAL, length);
3820 0           i2d_TS_TST_INFO(x, &ptr);
3821 0           set_buffer_length(RETVAL, length);
3822             } else
3823 0           RETVAL = &PL_sv_undef;
3824             OUTPUT: RETVAL
3825              
3826             MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::Timestamp::Response PREFIX = TS_RESP_
3827              
3828             Crypt::OpenSSL3::Timestamp::Response TS_RESP_new(class)
3829             C_ARGS:
3830              
3831             bool TS_RESP_set_status_info(Crypt::OpenSSL3::Timestamp::Response a, Crypt::OpenSSL3::Timestamp::StatusInfo info)
3832              
3833             Crypt::OpenSSL3::Timestamp::StatusInfo TS_RESP_get_status_info(Crypt::OpenSSL3::Timestamp::Response a)
3834              
3835             Crypt::OpenSSL3::Timestamp::TokenInfo TS_RESP_get_tst_info(Crypt::OpenSSL3::Timestamp::Response a)
3836             POSTCALL:
3837 0 0         if (RETVAL)
3838 0           RETVAL = TS_TST_INFO_dup(RETVAL);
3839             else
3840 0           XSRETURN_UNDEF;
3841              
3842             Crypt::OpenSSL3::PKCS7 TS_RESP_get_token(Crypt::OpenSSL3::Timestamp::Response a)
3843             POSTCALL:
3844 0 0         if (RETVAL)
3845 0           RETVAL = PKCS7_dup(RETVAL);
3846             else
3847 0           XSRETURN_UNDEF;
3848              
3849             PrintRet TS_RESP_print(Crypt::OpenSSL3::Timestamp::Response a, Crypt::OpenSSL3::BIO bio)
3850              
3851             Crypt::OpenSSL3::Timestamp::Response TS_RESP_read_der(class, Crypt::OpenSSL3::BIO bio)
3852             C_ARGS: bio, NULL
3853             POSTCALL:
3854 0 0         if (!RETVAL)
3855 0           XSRETURN_UNDEF;
3856              
3857             bool TS_RESP_write_der(Crypt::OpenSSL3::Timestamp::Response x, Crypt::OpenSSL3::BIO bio)
3858             C_ARGS: bio, x
3859              
3860             Crypt::OpenSSL3::Timestamp::Response TS_RESP_decode_der(class, ASN1_DECODER* buffer)
3861             CODE:
3862 0           RETVAL = d2i_TS_RESP(NULL, &buffer->ptr, buffer->end - buffer->ptr);
3863 0 0         if (!RETVAL)
3864 0           XSRETURN_UNDEF;
3865             OUTPUT: RETVAL
3866              
3867             SV* TS_RESP_encode_der(Crypt::OpenSSL3::Timestamp::Response x)
3868             CODE:
3869 0           int length = i2d_TS_RESP(x, NULL);
3870 0 0         if (length > 0) {
3871 0           unsigned char* ptr = make_buffer(&RETVAL, length);
3872 0           i2d_TS_RESP(x, &ptr);
3873 0           set_buffer_length(RETVAL, length);
3874             } else
3875 0           RETVAL = &PL_sv_undef;
3876             OUTPUT: RETVAL
3877              
3878              
3879             MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::Timestamp::StatusInfo PREFIX = TS_STATUS_INFO_
3880              
3881             Crypt::OpenSSL3::Timestamp::StatusInfo TS_STATUS_INFO_new(class)
3882             C_ARGS:
3883              
3884             bool TS_STATUS_INFO_set_status(Crypt::OpenSSL3::Timestamp::StatusInfo a, int i)
3885              
3886             const ASN1_INTEGER* TS_STATUS_INFO_get_status(Crypt::OpenSSL3::Timestamp::StatusInfo a)
3887              
3888             void TS_STATUS_INFO_get_text(Crypt::OpenSSL3::Timestamp::StatusInfo a)
3889             PPCODE:
3890 0           const STACK_OF(ASN1_UTF8STRING)* stack = TS_STATUS_INFO_get0_text(a);
3891 0 0         if (stack) {
3892 0           int num = sk_ASN1_UTF8STRING_num(stack);
3893 0 0         EXTEND(SP, num);
    0          
3894 0 0         for (int i = 0; i < num; ++i) {
3895 0           ASN1_UTF8STRING* orig = sk_ASN1_UTF8STRING_value(stack, i);
3896 0           mPUSHs(ASN1_STRING_to_SV(V_ASN1_UTF8STRING, orig));
3897             }
3898             }
3899              
3900             const ASN1_OCTET_STRING* TS_STATUS_INFO_get_failure_info(Crypt::OpenSSL3::Timestamp::StatusInfo a)
3901              
3902              
3903             MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::Timestamp::Accuracy PREFIX = TS_ACCURACY_
3904              
3905             Crypt::OpenSSL3::Timestamp::Accuracy TS_ACCURACY_new(class)
3906             C_ARGS:
3907              
3908             bool TS_ACCURACY_set_seconds(Crypt::OpenSSL3::Timestamp::Accuracy a, ASN1_INTEGER* seconds)
3909             INTERFACE: TS_ACCURACY_set_seconds TS_ACCURACY_set_millis TS_ACCURACY_set_micros
3910              
3911             ASN1_INTEGER* TS_ACCURACY_get_seconds(Crypt::OpenSSL3::Timestamp::Accuracy a)
3912             INTERFACE: TS_ACCURACY_get_seconds TS_ACCURACY_get_millis TS_ACCURACY_get_micros
3913             POSTCALL:
3914 0 0         if (!RETVAL)
3915 0           XSRETURN_UNDEF;
3916              
3917             MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::Timestamp::Responder PREFIX = TS_RESP_CTX_
3918              
3919              
3920             Crypt::OpenSSL3::Timestamp::Responder TS_RESP_CTX_new(class, const char *propq = NULL)
3921             C_ARGS: NULL, propq
3922              
3923             int TS_RESP_CTX_set_signer_cert(Crypt::OpenSSL3::Timestamp::Responder ctx, Crypt::OpenSSL3::X509 signer)
3924              
3925             int TS_RESP_CTX_set_signer_key(Crypt::OpenSSL3::Timestamp::Responder ctx, Crypt::OpenSSL3::PKey key)
3926              
3927             int TS_RESP_CTX_set_signer_digest(Crypt::OpenSSL3::Timestamp::Responder ctx, Crypt::OpenSSL3::MD signer_digest)
3928              
3929             int TS_RESP_CTX_set_ess_cert_id_digest(Crypt::OpenSSL3::Timestamp::Responder ctx, Crypt::OpenSSL3::MD md)
3930              
3931             int TS_RESP_CTX_set_def_policy(Crypt::OpenSSL3::Timestamp::Responder ctx, Crypt::OpenSSL3::ASN1::Object def_policy)
3932              
3933             int TS_RESP_CTX_set_certs(Crypt::OpenSSL3::Timestamp::Responder ctx, STACK_OF(X509) *certs)
3934             POSTCALL:
3935 0           sk_X509_free(certs);
3936              
3937             int TS_RESP_CTX_add_policy(Crypt::OpenSSL3::Timestamp::Responder ctx, Crypt::OpenSSL3::ASN1::Object policy)
3938              
3939             int TS_RESP_CTX_add_md(Crypt::OpenSSL3::Timestamp::Responder ctx, Crypt::OpenSSL3::MD md)
3940              
3941             int TS_RESP_CTX_set_accuracy(Crypt::OpenSSL3::Timestamp::Responder ctx, int secs, int millis, int micros)
3942              
3943             int TS_RESP_CTX_set_clock_precision_digits(Crypt::OpenSSL3::Timestamp::Responder ctx, unsigned clock_precision_digits)
3944              
3945             void TS_RESP_CTX_add_flags(Crypt::OpenSSL3::Timestamp::Responder ctx, int flags)
3946              
3947             void TS_RESP_CTX_set_serial_cb(Crypt::OpenSSL3::Timestamp::Responder ctx, SV *data)
3948             C_ARGS: ctx, TS_RESP_CTX_serial_callback, data
3949              
3950             void TS_RESP_CTX_set_time_cb(Crypt::OpenSSL3::Timestamp::Responder ctx, SV *data)
3951             C_ARGS: ctx, TS_RESP_CTX_time_callback, data
3952              
3953             # void TS_RESP_CTX_set_extension_cb(Crypt::OpenSSL3::Timestamp::Responder ctx, void *data)
3954              
3955             int TS_RESP_CTX_set_status_info(Crypt::OpenSSL3::Timestamp::Responder ctx, int status, const char *text)
3956              
3957             int TS_RESP_CTX_set_status_info_cond(Crypt::OpenSSL3::Timestamp::Responder ctx, int status, const char *text)
3958              
3959             int TS_RESP_CTX_add_failure_info(Crypt::OpenSSL3::Timestamp::Responder ctx, int failure)
3960              
3961             Crypt::OpenSSL3::Timestamp::Request TS_RESP_CTX_get_request(Crypt::OpenSSL3::Timestamp::Responder ctx)
3962             POSTCALL:
3963 0 0         if (RETVAL)
3964 0           RETVAL = TS_REQ_dup(RETVAL);
3965              
3966             Crypt::OpenSSL3::Timestamp::TokenInfo TS_RESP_CTX_get_tst_info(Crypt::OpenSSL3::Timestamp::Responder ctx)
3967             POSTCALL:
3968 0 0         if (RETVAL)
3969 0           RETVAL = TS_TST_INFO_dup(RETVAL);
3970              
3971             Crypt::OpenSSL3::Timestamp::Response TS_RESP_CTX_create_response(Crypt::OpenSSL3::Timestamp::Responder ctx, Crypt::OpenSSL3::BIO req_bio)
3972             POSTCALL:
3973 0 0         if (RETVAL)
3974 0           RETVAL = TS_RESP_dup(RETVAL);
3975              
3976              
3977             MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::Timestamp::Verifier PREFIX = TS_VERIFY_CTX_
3978              
3979             BOOT:
3980             {
3981 62           HV* stash = gv_stashpvs("Crypt::OpenSSL3::Timestamp::Verifier", GV_ADD | GV_ADDMULTI);
3982 62           CONSTANT2(TS_, VFY_SIGNATURE);
3983 62           CONSTANT2(TS_, VFY_VERSION);
3984 62           CONSTANT2(TS_, VFY_POLICY);
3985 62           CONSTANT2(TS_, VFY_IMPRINT);
3986 62           CONSTANT2(TS_, VFY_DATA);
3987 62           CONSTANT2(TS_, VFY_NONCE);
3988 62           CONSTANT2(TS_, VFY_SIGNER);
3989 62           CONSTANT2(TS_, VFY_TSA_NAME);
3990 62           CONSTANT2(TS_, VFY_ALL_IMPRINT);
3991 62           CONSTANT2(TS_, VFY_ALL_DATA);
3992             }
3993              
3994             Crypt::OpenSSL3::Timestamp::Verifier TS_VERIFY_CTX_new(class)
3995             C_ARGS:
3996             POSTCALL:
3997 0           TS_VERIFY_CTX_init(RETVAL);
3998              
3999             bool TS_VERIFY_CTX_init_from_request(Crypt::OpenSSL3::Timestamp::Verifier ctx, Crypt::OpenSSL3::Timestamp::Request req)
4000              
4001             int TS_VERIFY_CTX_set_flags(Crypt::OpenSSL3::Timestamp::Verifier ctx, int f)
4002              
4003             int TS_VERIFY_CTX_add_flags(Crypt::OpenSSL3::Timestamp::Verifier ctx, int f)
4004              
4005             bool TS_VERIFY_CTX_set_data(Crypt::OpenSSL3::Timestamp::Verifier ctx, Crypt::OpenSSL3::BIO b)
4006             POSTCALL:
4007 0 0         if (RETVAL)
4008 0           BIO_up_ref(b);
4009              
4010             bool TS_VERIFY_CTX_set_imprint(Crypt::OpenSSL3::Timestamp::Verifier ctx, unsigned char *hexstr, long length(hexstr))
4011              
4012             bool TS_VERIFY_CTX_set_store(Crypt::OpenSSL3::Timestamp::Verifier ctx, Crypt::OpenSSL3::X509::Store s)
4013             POSTCALL:
4014 0 0         if (RETVAL)
4015 0           X509_STORE_up_ref(s);
4016              
4017             bool TS_VERIFY_CTX_set_certs(Crypt::OpenSSL3::Timestamp::Verifier ctx, STACK_OF(X509)* certs)
4018              
4019             int TS_VERIFY_CTX_verify_response(Crypt::OpenSSL3::Timestamp::Verifier ctx, Crypt::OpenSSL3::Timestamp::Response response)
4020              
4021             int TS_VERIFY_CTX_verify_token(Crypt::OpenSSL3::Timestamp::Verifier ctx, Crypt::OpenSSL3::PKCS7 token)
4022              
4023             Bool CLONE_SKIP(...)
4024              
4025              
4026             MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::NID PREFIX = NID_
4027              
4028             Crypt::OpenSSL3::NID NID_create(class, const char *oid, const char *sn, const char *ln)
4029             C_ARGS: oid, sn, ln
4030             POSTCALL:
4031 0 0         if (RETVAL == NID_undef)
4032 0           XSRETURN_UNDEF;
4033              
4034             Crypt::OpenSSL3::NID NID_from_long_name(class, const char* name)
4035             C_ARGS: name
4036              
4037             Crypt::OpenSSL3::NID NID_from_short_name(class, const char* name)
4038             C_ARGS: name
4039              
4040             Crypt::OpenSSL3::NID NID_from_text(class, const char* name)
4041             C_ARGS: name
4042              
4043             const char *NID_get_long_name(Crypt::OpenSSL3::NID n)
4044              
4045             const char *NID_get_short_name(Crypt::OpenSSL3::NID n)
4046              
4047             Crypt::OpenSSL3::ASN1::Object NID_to_object(Crypt::OpenSSL3::NID n)
4048              
4049             bool NID_eq(Crypt::OpenSSL3::NID left, Crypt::OpenSSL3::NID right)
4050              
4051             int NID_raw(Crypt::OpenSSL3::NID n)
4052              
4053             bool NID_is_undef(Crypt::OpenSSL3::NID n)
4054              
4055              
4056             MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::Random PREFIX = EVP_RAND_
4057              
4058             Crypt::OpenSSL3::Random EVP_RAND_fetch(classname, const char* algorithm, const char* properties = "")
4059             C_ARGS: NULL, algorithm, properties
4060             POSTCALL:
4061 0 0         if (RETVAL == NULL)
4062 0           XSRETURN_UNDEF;
4063              
4064             bool EVP_RAND_is_a(Crypt::OpenSSL3::Random rand, const char *name)
4065              
4066             const char *EVP_RAND_get_name(Crypt::OpenSSL3::Random rand)
4067              
4068             const char *EVP_RAND_get_description(Crypt::OpenSSL3::Random rand)
4069              
4070             void EVP_RAND_names_list_all(Crypt::OpenSSL3::Random rand)
4071             PPCODE:
4072 0           PUTBACK;
4073 0           EVP_RAND_names_do_all(rand, EVP_name_callback, iTHX);
4074 0           SPAGAIN;
4075              
4076             void EVP_RAND_list_all_provided(classname)
4077             PPCODE:
4078 0           PUTBACK;
4079 0           EVP_RAND_do_all_provided(NULL, EVP_RAND_provided_callback, iTHX);
4080 0           SPAGAIN;
4081              
4082             SV* EVP_RAND_get_param(Crypt::OpenSSL3::Random rand, const char* name)
4083             CODE:
4084 0 0         GENERATE_GET_PARAM(EVP_RAND, rand, name)
    0          
    0          
    0          
4085             OUTPUT: RETVAL
4086              
4087             MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::Random PREFIX = RAND_
4088              
4089             NO_OUTPUT int RAND_bytes(classname, OUTLIST SV* buffer, int num)
4090             INTERFACE: RAND_bytes RAND_priv_bytes
4091             INIT:
4092 0           unsigned char* ptr = make_buffer(&buffer, num);
4093             C_ARGS: ptr, num
4094             POSTCALL:
4095 0 0         if (RETVAL > 0)
4096 0           set_buffer_length(buffer, num);
4097              
4098             Crypt::OpenSSL3::Random::Context RAND_get_primary(classname)
4099             INTERFACE: RAND_get_primary RAND_get_public RAND_get_private
4100             C_ARGS: NULL
4101             POSTCALL:
4102             EVP_RAND_CTX_up_ref(RETVAL);
4103              
4104             #if OPENSSL_VERSION_PREREQ(3, 2)
4105             Bool RAND_set_public(classname, Crypt::OpenSSL3::Random::Context rand)
4106             INTERFACE: RAND_set_public RAND_set_private
4107             C_ARGS: NULL, rand
4108             POSTCALL:
4109             if (RETVAL)
4110             EVP_RAND_CTX_up_ref(rand);
4111             #endif
4112              
4113             MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::Random::Context PREFIX = EVP_RAND_CTX_
4114              
4115             Crypt::OpenSSL3::Random::Context EVP_RAND_CTX_new(classname, Crypt::OpenSSL3::Random type, Crypt::OpenSSL3::Random::Context parent = NULL)
4116             C_ARGS: type, parent
4117              
4118             Crypt::OpenSSL3::Random EVP_RAND_CTX_get_rand(Crypt::OpenSSL3::Random::Context ctx)
4119             POSTCALL:
4120 0           EVP_RAND_up_ref(RETVAL);
4121              
4122             MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::Random::Context PREFIX = EVP_RAND_
4123              
4124             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)
4125              
4126             bool EVP_RAND_uninstantiate(Crypt::OpenSSL3::Random::Context ctx)
4127              
4128             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))
4129             INIT:
4130 0           unsigned char* ptr = make_buffer(&buffer, outlen);
4131             C_ARGS: ctx, ptr, outlen, strength, prediction_resistance, addin, XSauto_length_of_addin
4132             POSTCALL:
4133 0 0         if (RETVAL)
4134 0           set_buffer_length(buffer, outlen);
4135              
4136             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)
4137              
4138             NO_OUTPUT int EVP_RAND_nonce(Crypt::OpenSSL3::Random::Context ctx, OUTLIST SV* buffer, size_t outlen)
4139             INIT:
4140 0           unsigned char* ptr = make_buffer(&buffer, outlen);
4141             C_ARGS: ctx, ptr, outlen
4142             POSTCALL:
4143 0           set_buffer_length(buffer, RETVAL);
4144              
4145             bool EVP_RAND_enable_locking(Crypt::OpenSSL3::Random::Context ctx)
4146              
4147             bool EVP_RAND_verify_zeroization(Crypt::OpenSSL3::Random::Context ctx)
4148              
4149             unsigned int EVP_RAND_get_strength(Crypt::OpenSSL3::Random::Context ctx)
4150              
4151             int EVP_RAND_get_state(Crypt::OpenSSL3::Random::Context ctx)
4152              
4153              
4154             MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::Cipher PREFIX = EVP_CIPHER_
4155              
4156             Crypt::OpenSSL3::Cipher EVP_CIPHER_fetch(classname, const char* algorithm, const char* properties = "")
4157             C_ARGS: NULL, algorithm, properties
4158             POSTCALL:
4159 1 50         if (RETVAL == NULL)
4160 0           XSRETURN_UNDEF;
4161              
4162             Crypt::OpenSSL3::NID EVP_CIPHER_get_nid(Crypt::OpenSSL3::Cipher e)
4163              
4164             int EVP_CIPHER_get_block_size(Crypt::OpenSSL3::Cipher e)
4165              
4166             int EVP_CIPHER_get_key_length(Crypt::OpenSSL3::Cipher e)
4167              
4168             int EVP_CIPHER_get_iv_length(Crypt::OpenSSL3::Cipher e)
4169              
4170             unsigned long EVP_CIPHER_get_mode(Crypt::OpenSSL3::Cipher e)
4171              
4172             int EVP_CIPHER_get_type(Crypt::OpenSSL3::Cipher cipher)
4173              
4174             bool EVP_CIPHER_is_a(Crypt::OpenSSL3::Cipher cipher, const char *name)
4175              
4176             const char *EVP_CIPHER_get_name(Crypt::OpenSSL3::Cipher cipher)
4177              
4178             const char *EVP_CIPHER_get_description(Crypt::OpenSSL3::Cipher cipher)
4179              
4180             void EVP_CIPHER_names_list_all(Crypt::OpenSSL3::Cipher cipher)
4181             PPCODE:
4182 0           PUTBACK;
4183 0           EVP_CIPHER_names_do_all(cipher, EVP_name_callback, iTHX);
4184 0           SPAGAIN;
4185              
4186             void EVP_CIPHER_list_all_provided(classname)
4187             PPCODE:
4188 1           PUTBACK;
4189 1           EVP_CIPHER_do_all_provided(NULL, EVP_CIPHER_provided_callback, iTHX);
4190 1           SPAGAIN;
4191              
4192             SV* EVP_CIPHER_get_param(Crypt::OpenSSL3::Cipher cipher, const char* name)
4193             CODE:
4194 0 0         GENERATE_GET_PARAM(EVP_CIPHER, cipher, name)
    0          
    0          
    0          
4195             OUTPUT: RETVAL
4196              
4197              
4198             MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::Cipher::Context PREFIX = EVP_CIPHER_CTX_
4199              
4200             Crypt::OpenSSL3::Cipher::Context EVP_CIPHER_CTX_new(classname)
4201             C_ARGS:
4202              
4203             Crypt::OpenSSL3::Cipher::Context EVP_CIPHER_CTX_dup(Crypt::OpenSSL3::Cipher::Context ctx)
4204              
4205             bool EVP_CIPHER_CTX_copy(Crypt::OpenSSL3::Cipher::Context self, Crypt::OpenSSL3::Cipher::Context other)
4206              
4207             bool EVP_CIPHER_CTX_reset(Crypt::OpenSSL3::Cipher::Context ctx)
4208              
4209             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)
4210             INIT:
4211 2 50         if (XSauto_length_of_key != EVP_CIPHER_get_key_length(type) || XSauto_length_of_iv != EVP_CIPHER_get_iv_length(type))
    50          
4212 0           XSRETURN_NO;
4213             C_ARGS: ctx, type, key, iv, enc, params
4214              
4215             NO_OUTPUT int EVP_CIPHER_CTX_update(Crypt::OpenSSL3::Cipher::Context ctx, const unsigned char* input, size_t length(input), OUTLIST SV* output)
4216             INIT:
4217 2           int outl = XSauto_length_of_input + EVP_CIPHER_CTX_get_block_size(ctx);
4218 2           unsigned char* ptr = make_buffer(&output, outl);
4219             C_ARGS: ctx, ptr, &outl, input, XSauto_length_of_input
4220             POSTCALL:
4221 2 50         if (RETVAL)
4222 2           set_buffer_length(output, outl);
4223              
4224             NO_OUTPUT int EVP_CIPHER_CTX_final(Crypt::OpenSSL3::Cipher::Context ctx, OUTLIST SV* output)
4225             INIT:
4226 2           int size = EVP_CIPHER_CTX_get_block_size(ctx);
4227 2           unsigned char* ptr = make_buffer(&output, size);
4228             C_ARGS: ctx, ptr, &size
4229             POSTCALL:
4230 2 50         if (RETVAL)
4231 2           set_buffer_length(output, size);
4232              
4233             bool EVP_CIPHER_CTX_set_params(Crypt::OpenSSL3::Cipher::Context ctx, PARAMS(EVP_CIPHER_CTX) params = NULL)
4234              
4235             SV* EVP_CIPHER_CTX_get_param(Crypt::OpenSSL3::Cipher::Context ctx, const char* name)
4236             CODE:
4237 1 50         GENERATE_GET_PARAM(EVP_CIPHER_CTX, ctx, name)
    50          
    50          
    50          
4238             OUTPUT: RETVAL
4239              
4240              
4241             Crypt::OpenSSL3::NID EVP_CIPHER_CTX_get_nid(Crypt::OpenSSL3::Cipher::Context e)
4242              
4243             int EVP_CIPHER_CTX_get_block_size(Crypt::OpenSSL3::Cipher::Context e)
4244              
4245             int EVP_CIPHER_CTX_get_key_length(Crypt::OpenSSL3::Cipher::Context e)
4246              
4247             int EVP_CIPHER_CTX_get_iv_length(Crypt::OpenSSL3::Cipher::Context e)
4248              
4249             unsigned long EVP_CIPHER_CTX_get_mode(Crypt::OpenSSL3::Cipher::Context e)
4250              
4251             int EVP_CIPHER_CTX_type(Crypt::OpenSSL3::Cipher::Context ctx)
4252              
4253             bool EVP_CIPHER_CTX_set_padding(Crypt::OpenSSL3::Cipher::Context ctx, int padding)
4254              
4255             bool EVP_CIPHER_CTX_set_key_length(Crypt::OpenSSL3::Cipher::Context ctx, int keylen)
4256              
4257             int EVP_CIPHER_CTX_ctrl(Crypt::OpenSSL3::Cipher::Context ctx, int cmd, int p1, char *p2)
4258              
4259             NO_OUTPUT int EVP_CIPHER_CTX_rand_key(Crypt::OpenSSL3::Cipher::Context ctx, OUTLIST SV* key)
4260             INIT:
4261 0           size_t size = EVP_CIPHER_CTX_key_length(ctx);
4262 0           unsigned char* ptr = make_buffer(&key, size);
4263             C_ARGS: ctx, ptr
4264             POSTCALL:
4265 0 0         if (RETVAL > 0)
4266 0           set_buffer_length(key, size);
4267              
4268             Crypt::OpenSSL3::Cipher EVP_CIPHER_CTX_get_cipher(Crypt::OpenSSL3::Cipher::Context ctx)
4269              
4270             const char *EVP_CIPHER_CTX_get_name(Crypt::OpenSSL3::Cipher::Context ctx)
4271              
4272             bool EVP_CIPHER_CTX_is_encrypting(Crypt::OpenSSL3::Cipher::Context ctx)
4273              
4274             bool EVP_CIPHER_CTX_set_aead_ivlen(Crypt::OpenSSL3::Cipher::Context ctx, int length)
4275              
4276             NO_OUTPUT bool EVP_CIPHER_CTX_get_aead_tag(Crypt::OpenSSL3::Cipher::Context ctx, OUTLIST SV* tag)
4277             INIT:
4278 1           int length = EVP_CIPHER_CTX_get_tag_length(ctx);
4279 1           unsigned char* ptr = make_buffer(&tag, length);
4280             C_ARGS: ctx, ptr, length
4281             POSTCALL:
4282 1 50         if (RETVAL)
4283 1           set_buffer_length(tag, length);
4284              
4285             bool EVP_CIPHER_CTX_set_aead_tag(Crypt::OpenSSL3::Cipher::Context ctx, char* ptr, int length(ptr))
4286              
4287             #if OPENSSL_VERSION_PREREQ(3, 4)
4288             NO_OUTPUT int EVP_CIPHER_CTX_get_algor(Crypt::OpenSSL3::Cipher::Context ctx, OUTLIST Crypt::OpenSSL3::X509::Algorithm alg)
4289             INIT:
4290             alg = NULL;
4291             POSTCALL:
4292             if (!RETVAL)
4293             XSRETURN_UNDEF;
4294             #endif
4295              
4296             MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::MD PREFIX = EVP_MD_
4297              
4298             Crypt::OpenSSL3::MD EVP_MD_fetch(classname, const char* algorithm, const char* properties = "")
4299             C_ARGS: NULL, algorithm, properties
4300             POSTCALL:
4301 1 50         if (RETVAL == NULL)
4302 0           XSRETURN_UNDEF;
4303              
4304             const char *EVP_MD_get_name(Crypt::OpenSSL3::MD md)
4305              
4306             const char *EVP_MD_get_description(Crypt::OpenSSL3::MD md)
4307              
4308             bool EVP_MD_is_a(Crypt::OpenSSL3::MD md, const char *name)
4309              
4310             void EVP_MD_names_list_all(Crypt::OpenSSL3::MD md)
4311             PPCODE:
4312 0           PUTBACK;
4313 0           EVP_MD_names_do_all(md, EVP_name_callback, iTHX);
4314 0           SPAGAIN;
4315              
4316             void EVP_MD_list_all_provided(classname)
4317             PPCODE:
4318 1           PUTBACK;
4319 1           EVP_MD_do_all_provided(NULL, EVP_MD_provided_callback, iTHX);
4320 1           SPAGAIN;
4321              
4322             Crypt::OpenSSL3::NID EVP_MD_get_type(Crypt::OpenSSL3::MD md)
4323              
4324             Crypt::OpenSSL3::NID EVP_MD_get_pkey_type(Crypt::OpenSSL3::MD md)
4325              
4326             int EVP_MD_get_size(Crypt::OpenSSL3::MD md)
4327              
4328             int EVP_MD_get_block_size(Crypt::OpenSSL3::MD md)
4329              
4330             unsigned long EVP_MD_get_flags(Crypt::OpenSSL3::MD md)
4331              
4332             #if OPENSSL_VERSION_PREREQ(3, 4)
4333             bool EVP_MD_xof(Crypt::OpenSSL3::MD md)
4334             #endif
4335              
4336             SV* EVP_MD_get_param(Crypt::OpenSSL3::MD md, const char* name)
4337             CODE:
4338 0 0         GENERATE_GET_PARAM(EVP_MD, md, name)
    0          
    0          
    0          
4339             OUTPUT: RETVAL
4340              
4341             NO_OUTPUT bool EVP_MD_digest(Crypt::OpenSSL3::MD md, const char* input, size_t length(input), OUTLIST SV* digest)
4342             INIT:
4343 0           unsigned int size = EVP_MD_get_size(md);
4344 0           unsigned char* ptr = make_buffer(&digest, size);
4345             C_ARGS: input, XSauto_length_of_input, ptr, &size, md, NULL
4346             POSTCALL:
4347 0 0         if (RETVAL)
4348 0           set_buffer_length(digest, size);
4349              
4350              
4351             MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::MD::Context PREFIX = EVP_MD_CTX_
4352              
4353             Crypt::OpenSSL3::MD::Context EVP_MD_CTX_new(classname)
4354             C_ARGS:
4355              
4356             Crypt::OpenSSL3::MD::Context EVP_MD_CTX_dup(Crypt::OpenSSL3::MD::Context ctx)
4357              
4358             bool EVP_MD_CTX_copy(Crypt::OpenSSL3::MD::Context self, Crypt::OpenSSL3::MD::Context other)
4359              
4360             bool EVP_MD_CTX_reset(Crypt::OpenSSL3::MD::Context ctx)
4361              
4362             bool EVP_MD_CTX_init(Crypt::OpenSSL3::MD::Context ctx, Crypt::OpenSSL3::MD type, CTX_PARAMS(EVP_MD) params = NULL)
4363              
4364             bool EVP_MD_CTX_update(Crypt::OpenSSL3::MD::Context ctx, const char *d, size_t length(d))
4365              
4366             NO_OUTPUT bool EVP_MD_CTX_final(Crypt::OpenSSL3::MD::Context ctx, OUTLIST SV* digest)
4367             INIT:
4368 1           unsigned int size = EVP_MD_CTX_size(ctx);
4369 1           unsigned char* ptr = make_buffer(&digest , size);
4370             C_ARGS: ctx, ptr, &size
4371             POSTCALL:
4372 1 50         if (RETVAL)
4373 1           set_buffer_length(digest, size);
4374              
4375             NO_OUTPUT bool EVP_MD_CTX_final_xof(Crypt::OpenSSL3::MD::Context ctx, OUTLIST SV* digest, size_t outlen)
4376             INIT:
4377 0           unsigned char* ptr = make_buffer(&digest, outlen);
4378             C_ARGS: ctx, ptr, outlen
4379             POSTCALL:
4380 0 0         if (RETVAL)
4381 0           set_buffer_length(digest, outlen);
4382              
4383             #if OPENSSL_VERSION_PREREQ(3, 3)
4384             NO_OUTPUT bool EVP_MD_CTX_squeeze(Crypt::OpenSSL3::MD::Context ctx, OUTLIST SV* digest, size_t outlen)
4385             INIT:
4386             unsigned char* ptr = make_buffer(&digest, outlen);
4387             C_ARGS: ctx, ptr, outlen
4388             POSTCALL:
4389             if (RETVAL)
4390             set_buffer_length(digest, outlen);
4391             #endif
4392              
4393             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)
4394             C_ARGS: ctx, pctx ? &pctx : NULL, type, NULL, pkey
4395              
4396             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)
4397             C_ARGS: ctx, pctx ? &pctx : NULL, mdname, NULL, props, pkey, NULL
4398              
4399             bool EVP_MD_CTX_sign_update(Crypt::OpenSSL3::MD::Context ctx, const char *d, size_t length(d))
4400              
4401             SV* EVP_MD_CTX_sign_final(Crypt::OpenSSL3::MD::Context ctx)
4402             CODE:
4403 1           size_t size = 0;
4404 1 50         if (EVP_DigestSignFinal(ctx, NULL, &size) == 1) {
4405 1           unsigned char* ptr = make_buffer(&RETVAL, size);
4406 1 50         if (EVP_DigestSignFinal(ctx, ptr, &size) == 1)
4407 1           set_buffer_length(RETVAL, size);
4408             } else
4409 0           RETVAL = &PL_sv_undef;
4410             OUTPUT: RETVAL
4411              
4412             SV* EVP_MD_CTX_sign(Crypt::OpenSSL3::MD::Context ctx, const unsigned char *tbs, size_t length(tbs))
4413             CODE:
4414 0           size_t size = 0;
4415 0 0         if (EVP_DigestSign(ctx, NULL, &size, tbs, XSauto_length_of_tbs) == 1) {
4416 0           unsigned char* ptr = make_buffer(&RETVAL, size);
4417 0 0         if (EVP_DigestSign(ctx, ptr, &size, tbs, XSauto_length_of_tbs) == 1)
4418 0           set_buffer_length(RETVAL, size);
4419             } else
4420 0           RETVAL = &PL_sv_undef;
4421             OUTPUT: RETVAL
4422              
4423             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)
4424             C_ARGS: ctx, pctx ? &pctx : NULL, type, NULL, pkey
4425            
4426             bool EVP_MD_CTX_verify_update(Crypt::OpenSSL3::MD::Context ctx, const char *d, size_t length(d))
4427              
4428             Success EVP_MD_CTX_verify_final(Crypt::OpenSSL3::MD::Context ctx, const unsigned char *sig, size_t length(sig))
4429              
4430             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))
4431              
4432             bool EVP_MD_CTX_set_params(Crypt::OpenSSL3::MD::Context ctx, PARAMS(EVP_MD_CTX) params = NULL)
4433              
4434             SV* EVP_MD_CTX_get_param(Crypt::OpenSSL3::MD::Context ctx, const char* name)
4435             CODE:
4436 0 0         GENERATE_GET_PARAM(EVP_MD_CTX, ctx, name)
    0          
    0          
    0          
4437             OUTPUT: RETVAL
4438              
4439              
4440             void EVP_MD_CTX_ctrl(Crypt::OpenSSL3::MD::Context ctx, int cmd, int p1, char* p2);
4441              
4442             void EVP_MD_CTX_set_flags(Crypt::OpenSSL3::MD::Context ctx, int flags)
4443              
4444             void EVP_MD_CTX_clear_flags(Crypt::OpenSSL3::MD::Context ctx, int flags)
4445              
4446             int EVP_MD_CTX_test_flags(Crypt::OpenSSL3::MD::Context ctx, int flags)
4447              
4448             Crypt::OpenSSL3::MD EVP_MD_CTX_get_md(Crypt::OpenSSL3::MD::Context ctx)
4449              
4450             const char *EVP_MD_CTX_get_name(Crypt::OpenSSL3::MD::Context ctx)
4451              
4452             int EVP_MD_CTX_get_size(Crypt::OpenSSL3::MD::Context ctx)
4453              
4454             int EVP_MD_CTX_get_block_size(Crypt::OpenSSL3::MD::Context ctx)
4455              
4456             int EVP_MD_CTX_get_type(Crypt::OpenSSL3::MD::Context ctx)
4457              
4458              
4459              
4460             MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::MAC PREFIX = EVP_MAC_
4461              
4462             Crypt::OpenSSL3::MAC EVP_MAC_fetch(classname, const char* algorithm, const char* properties = "")
4463             C_ARGS: NULL, algorithm, properties
4464             POSTCALL:
4465 1 50         if (RETVAL == NULL)
4466 0           XSRETURN_UNDEF;
4467              
4468             const char *EVP_MAC_get_name(Crypt::OpenSSL3::MAC mac)
4469              
4470             const char *EVP_MAC_get_description(Crypt::OpenSSL3::MAC mac)
4471              
4472             bool EVP_MAC_is_a(Crypt::OpenSSL3::MAC mac, const char *name)
4473              
4474             void EVP_MAC_names_list_all(Crypt::OpenSSL3::MAC mac)
4475             PPCODE:
4476 0           PUTBACK;
4477 0           EVP_MAC_names_do_all(mac, EVP_name_callback, iTHX);
4478 0           SPAGAIN;
4479              
4480             void EVP_MAC_list_all_provided(classname)
4481             PPCODE:
4482 1           PUTBACK;
4483 1           EVP_MAC_do_all_provided(NULL, EVP_MAC_provided_callback, iTHX);
4484 1           SPAGAIN;
4485              
4486             SV* EVP_MAC_get_param(Crypt::OpenSSL3::MAC mac, const char* name)
4487             CODE:
4488 0 0         GENERATE_GET_PARAM(EVP_MAC, mac, name)
    0          
    0          
    0          
4489             OUTPUT: RETVAL
4490              
4491              
4492              
4493             MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::MAC::Context PREFIX = EVP_MAC_CTX_
4494              
4495             Crypt::OpenSSL3::MAC::Context EVP_MAC_CTX_new(classname, Crypt::OpenSSL3::MAC ctx)
4496             C_ARGS: ctx
4497              
4498             Crypt::OpenSSL3::MAC::Context EVP_MAC_CTX_dup(Crypt::OpenSSL3::MAC::Context ctx)
4499              
4500             Crypt::OpenSSL3::MAC EVP_MAC_CTX_get_mac(Crypt::OpenSSL3::MAC::Context ctx);
4501             POSTCALL:
4502 0           EVP_MAC_up_ref(RETVAL);
4503              
4504             size_t EVP_MAC_CTX_get_mac_size(Crypt::OpenSSL3::MAC::Context ctx)
4505              
4506             size_t EVP_MAC_CTX_get_block_size(Crypt::OpenSSL3::MAC::Context ctx)
4507              
4508             bool EVP_MAC_CTX_set_params(Crypt::OpenSSL3::MAC::Context ctx, PARAMS(EVP_MAC_CTX) params = NULL)
4509              
4510             SV* EVP_MAC_CTX_get_param(Crypt::OpenSSL3::MAC::Context ctx, const char* name)
4511             CODE:
4512 0 0         GENERATE_GET_PARAM(EVP_MAC_CTX, ctx, name)
    0          
    0          
    0          
4513             OUTPUT: RETVAL
4514              
4515              
4516              
4517             MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::MAC::Context PREFIX = EVP_MAC_
4518              
4519             bool EVP_MAC_init(Crypt::OpenSSL3::MAC::Context ctx, const unsigned char *key, size_t length(key), PARAMS(EVP_MAC_CTX) params = NULL)
4520              
4521             bool EVP_MAC_update(Crypt::OpenSSL3::MAC::Context ctx, const unsigned char *data, size_t length(data))
4522              
4523             SV* EVP_MAC_final(Crypt::OpenSSL3::MAC::Context ctx)
4524             CODE:
4525 1           size_t outsize = 0;
4526 1 50         if (EVP_MAC_final(ctx, NULL, &outsize, 0)) {
4527 1           unsigned char* ptr = make_buffer(&RETVAL, outsize);
4528 1           int result = EVP_MAC_final(ctx, ptr, &outsize, outsize);
4529 1 50         if (result)
4530 1           set_buffer_length(RETVAL, outsize);
4531             } else
4532 0           RETVAL = &PL_sv_undef;
4533             OUTPUT: RETVAL
4534              
4535             NO_OUTPUT int EVP_MAC_finalXOF(Crypt::OpenSSL3::MAC::Context ctx, OUTLIST SV* code, size_t outsize)
4536             INIT:
4537 0           unsigned char* ptr = make_buffer(&code, outsize);
4538             C_ARGS: ctx, ptr, outsize
4539             POSTCALL:
4540 0 0         if (RETVAL)
4541 0           set_buffer_length(code, outsize);
4542              
4543              
4544              
4545             MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::KDF PREFIX = EVP_KDF_
4546              
4547             Crypt::OpenSSL3::KDF EVP_KDF_fetch(classname, const char* algorithm, const char* properties = "")
4548             C_ARGS: NULL, algorithm, properties
4549             POSTCALL:
4550 1 50         if (RETVAL == NULL)
4551 0           XSRETURN_UNDEF;
4552              
4553             const char *EVP_KDF_get_name(Crypt::OpenSSL3::KDF kdf)
4554              
4555             const char *EVP_KDF_get_description(Crypt::OpenSSL3::KDF kdf)
4556              
4557             bool EVP_KDF_is_a(Crypt::OpenSSL3::KDF kdf, const char *name)
4558              
4559             void EVP_KDF_names_list_all(Crypt::OpenSSL3::KDF kdf)
4560             PPCODE:
4561 0           PUTBACK;
4562 0           EVP_KDF_names_do_all(kdf, EVP_name_callback, iTHX);
4563 0           SPAGAIN;
4564              
4565             void EVP_KDF_list_all_provided(classname)
4566             PPCODE:
4567 1           PUTBACK;
4568 1           EVP_KDF_do_all_provided(NULL, EVP_KDF_provided_callback, iTHX);
4569 1           SPAGAIN;
4570              
4571             SV* EVP_KDF_get_param(Crypt::OpenSSL3::KDF kdf, const char* name)
4572             CODE:
4573 0 0         GENERATE_GET_PARAM(EVP_KDF, kdf, name)
    0          
    0          
    0          
4574             OUTPUT: RETVAL
4575              
4576              
4577             MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::KDF::Context PREFIX = EVP_KDF_CTX_
4578              
4579             Crypt::OpenSSL3::KDF::Context EVP_KDF_CTX_new(classname, Crypt::OpenSSL3::KDF ctx)
4580             C_ARGS: ctx
4581              
4582             Crypt::OpenSSL3::KDF::Context EVP_KDF_CTX_dup(Crypt::OpenSSL3::KDF::Context ctx)
4583              
4584             void EVP_KDF_CTX_reset(Crypt::OpenSSL3::KDF::Context ctx)
4585              
4586             size_t EVP_KDF_CTX_get_kdf_size(Crypt::OpenSSL3::KDF::Context ctx)
4587              
4588             bool EVP_KDF_CTX_set_params(Crypt::OpenSSL3::KDF::Context ctx, PARAMS(EVP_KDF_CTX) params = NULL)
4589              
4590             SV* EVP_KDF_CTX_get_param(Crypt::OpenSSL3::KDF::Context ctx, const char* name)
4591             CODE:
4592 0 0         GENERATE_GET_PARAM(EVP_KDF_CTX, ctx, name)
    0          
    0          
    0          
4593             OUTPUT: RETVAL
4594              
4595             Crypt::OpenSSL3::KDF EVP_KDF_CTX_kdf(Crypt::OpenSSL3::KDF::Context ctx)
4596             POSTCALL:
4597 0           EVP_KDF_up_ref(RETVAL);
4598              
4599              
4600             MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::KDF::Context PREFIX = EVP_KDF_
4601              
4602             NO_OUTPUT bool EVP_KDF_derive(Crypt::OpenSSL3::KDF::Context ctx, OUTLIST SV* derived, size_t keylen, PARAMS(EVP_KDF_CTX) params)
4603             INIT:
4604 1           unsigned char* ptr = make_buffer(&derived, keylen);
4605             C_ARGS: ctx, ptr, keylen, params
4606             POSTCALL:
4607 1 50         if (RETVAL)
4608 1           set_buffer_length(derived, keylen);
4609              
4610              
4611              
4612             MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::Signature PREFIX = EVP_SIGNATURE_
4613              
4614             Crypt::OpenSSL3::Signature EVP_SIGNATURE_fetch(classname, const char* algorithm, const char* properties = "")
4615             C_ARGS: NULL, algorithm, properties
4616             POSTCALL:
4617 0 0         if (RETVAL == NULL)
4618 0           XSRETURN_UNDEF;
4619              
4620             const char *EVP_SIGNATURE_get_name(Crypt::OpenSSL3::Signature signature)
4621              
4622             const char *EVP_SIGNATURE_get_description(Crypt::OpenSSL3::Signature signature)
4623              
4624             bool EVP_SIGNATURE_is_a(Crypt::OpenSSL3::Signature signature, const char *name)
4625              
4626             void EVP_SIGNATURE_names_list_all(Crypt::OpenSSL3::Signature signature)
4627             PPCODE:
4628 0           PUTBACK;
4629 0           EVP_SIGNATURE_names_do_all(signature, EVP_name_callback, iTHX);
4630 0           SPAGAIN;
4631              
4632             void EVP_SIGNATURE_list_all_provided(classname)
4633             PPCODE:
4634 0           PUTBACK;
4635 0           EVP_SIGNATURE_do_all_provided(NULL, EVP_SIGNATURE_provided_callback, iTHX);
4636 0           SPAGAIN;
4637              
4638              
4639             MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::PKey PREFIX = EVP_PKEY_
4640              
4641             BOOT:
4642             {
4643 62           HV* stash = gv_stashpvs("Crypt::OpenSSL3::PKey", GV_ADD | GV_ADDMULTI);
4644 62           CONSTANT2(EVP_PKEY_, KEY_PARAMETERS);
4645 62           CONSTANT2(EVP_PKEY_, PUBLIC_KEY);
4646 62           CONSTANT2(EVP_PKEY_, KEYPAIR);
4647             }
4648              
4649             Crypt::OpenSSL3::PKey EVP_PKEY_new(classname)
4650             C_ARGS:
4651              
4652             Crypt::OpenSSL3::PKey EVP_PKEY_new_raw_private_key(classname, const char *keytype, const unsigned char *key, size_t length(key), const char *propq = "")
4653             C_ARGS: NULL, keytype, propq, key, XSauto_length_of_key
4654             POSTCALL:
4655 0 0         if (RETVAL == NULL)
4656 0           XSRETURN_UNDEF;
4657              
4658             Crypt::OpenSSL3::PKey EVP_PKEY_new_raw_public_key(classname, const char *keytype, const unsigned char *key, size_t length(key), const char *propq = "")
4659             C_ARGS: NULL, keytype, propq, key, XSauto_length_of_key
4660             POSTCALL:
4661 0 0         if (RETVAL == NULL)
4662 0           XSRETURN_UNDEF;
4663              
4664             Crypt::OpenSSL3::PKey EVP_PKEY_dup(Crypt::OpenSSL3::PKey ctx)
4665              
4666             bool EVP_PKEY_eq(Crypt::OpenSSL3::PKey a, Crypt::OpenSSL3::PKey b)
4667              
4668             bool EVP_PKEY_parameters_eq(Crypt::OpenSSL3::PKey a, Crypt::OpenSSL3::PKey b)
4669              
4670             NO_OUTPUT void EVP_PKEY_get_raw_private_key(Crypt::OpenSSL3::PKey pkey, OUTLIST SV* key)
4671             CODE:
4672             size_t length;
4673 0           int result = EVP_PKEY_get_raw_private_key(pkey, NULL, &length);
4674 0 0         if (!result)
4675 0           XSRETURN_UNDEF;
4676 0           unsigned char* ptr = make_buffer(&key, length);
4677 0           result = EVP_PKEY_get_raw_private_key(pkey, ptr, &length);
4678 0 0         if (result)
4679 0           set_buffer_length(key, length);
4680              
4681              
4682             NO_OUTPUT void EVP_PKEY_get_raw_public_key(Crypt::OpenSSL3::PKey pkey, OUTLIST SV* key)
4683             CODE:
4684             size_t length;
4685 0           int result = EVP_PKEY_get_raw_public_key(pkey, NULL, &length);
4686 0 0         if (!result)
4687 0           XSRETURN_UNDEF;
4688 0           unsigned char* ptr = make_buffer(&key, length);
4689 0           result = EVP_PKEY_get_raw_public_key(pkey, ptr, &length);
4690 0 0         if (result)
4691 0           set_buffer_length(key, length);
4692              
4693             Crypt::OpenSSL3::PKey EVP_PKEY_read_pem_private_key(Crypt::OpenSSL3::BIO bio, SV* password_cb = undef, const char* propq = "")
4694             C_ARGS: bio, NULL, NULL, NULL, NULL, propq
4695             POSTCALL:
4696 0 0         if (!RETVAL)
4697 0           XSRETURN_UNDEF;
4698              
4699             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 = "")
4700             INIT:
4701 0 0         const EVP_CIPHER* cipher = SvOK(cipher_sv) ? get_EVP_CIPHER(aTHX_ cipher_sv) : NULL;
4702 0           STRLEN klen = 0;
4703 0           const unsigned char* kstr = NULL;
4704 0 0         if (SvOK(key))
4705 0           kstr = (unsigned char*)SvPV(key, klen);
4706             C_ARGS: bio, pkey, cipher, kstr, klen, NULL, NULL, NULL, propq
4707              
4708             Crypt::OpenSSL3::PKey EVP_PKEY_read_pem_public_key(Crypt::OpenSSL3::BIO bio, const char* propq = "")
4709             C_ARGS: bio, NULL, NULL, NULL, NULL, propq
4710             POSTCALL:
4711 0 0         if (!RETVAL)
4712 0           XSRETURN_UNDEF;
4713              
4714             bool EVP_PKEY_write_pem_public_key(Crypt::OpenSSL3::PKey pkey, Crypt::OpenSSL3::BIO bio, const char* propq = "")
4715             C_ARGS: bio, pkey, NULL, propq
4716              
4717             Crypt::OpenSSL3::PKey EVP_PKEY_read_der_public_key(class, Crypt::OpenSSL3::BIO bio, const char* propq = NULL)
4718             C_ARGS: bio, NULL, NULL, propq
4719             POSTCALL:
4720 0 0         if (!RETVAL)
4721 0           XSRETURN_UNDEF;
4722              
4723             Crypt::OpenSSL3::PKey EVP_PKEY_read_der_private_key(class, Crypt::OpenSSL3::BIO bio, const char* propq = NULL)
4724             C_ARGS: bio, NULL, NULL, propq
4725             POSTCALL:
4726 0 0         if (!RETVAL)
4727 0           XSRETURN_UNDEF;
4728              
4729             bool EVP_PKEY_write_der_public_key(Crypt::OpenSSL3::PKey a, Crypt::OpenSSL3::BIO bio)
4730             INTERFACE: EVP_PKEY_write_der_public_key EVP_PKEY_write_der_private_key
4731             C_ARGS: bio, a
4732              
4733             Crypt::OpenSSL3::PKey EVP_PKEY_decode_der_public_key(class, ASN1_DECODER* buffer)
4734             CODE:
4735 0           RETVAL = d2i_PUBKEY(NULL, &buffer->ptr, buffer->end - buffer->ptr);
4736 0 0         if (!RETVAL)
4737 0           XSRETURN_UNDEF;
4738             OUTPUT: RETVAL
4739              
4740             SV* EVP_PKEY_encode_der_public_key(Crypt::OpenSSL3::PKey x)
4741             CODE:
4742 0           int length = i2d_PUBKEY(x, NULL);
4743 0 0         if (length > 0) {
4744 0           unsigned char* ptr = make_buffer(&RETVAL, length);
4745 0           i2d_PUBKEY(x, &ptr);
4746 0           set_buffer_length(RETVAL, length);
4747             } else
4748 0           RETVAL = &PL_sv_undef;
4749             OUTPUT: RETVAL
4750              
4751             Crypt::OpenSSL3::PKey EVP_PKEY_decode_der_private_key(class, ASN1_DECODER* buffer)
4752             CODE:
4753 0           RETVAL = d2i_AutoPrivateKey(NULL, &buffer->ptr, buffer->end - buffer->ptr);
4754 0 0         if (!RETVAL)
4755 0           XSRETURN_UNDEF;
4756             OUTPUT: RETVAL
4757              
4758             SV* EVP_PKEY_encode_der_private_key(Crypt::OpenSSL3::PKey x)
4759             CODE:
4760 0           int length = i2d_PrivateKey(x, NULL);
4761 0 0         if (length > 0) {
4762 0           unsigned char* ptr = make_buffer(&RETVAL, length);
4763 0           i2d_PrivateKey(x, &ptr);
4764 0           set_buffer_length(RETVAL, length);
4765             } else
4766 0           RETVAL = &PL_sv_undef;
4767             OUTPUT: RETVAL
4768              
4769             Crypt::OpenSSL3::NID EVP_PKEY_get_id(Crypt::OpenSSL3::PKey pkey)
4770             POSTCALL:
4771 0 0         if (RETVAL == -1)
4772 0           XSRETURN_UNDEF;
4773              
4774             Crypt::OpenSSL3::NID EVP_PKEY_get_base_id(Crypt::OpenSSL3::PKey pkey)
4775              
4776             int EVP_PKEY_type(int type)
4777              
4778             bool EVP_PKEY_set_type(Crypt::OpenSSL3::PKey pkey, int type)
4779              
4780             bool EVP_PKEY_set_type_str(Crypt::OpenSSL3::PKey pkey, const char *str, int length(str))
4781              
4782             int EVP_PKEY_get_size(Crypt::OpenSSL3::PKey pkey)
4783              
4784             int EVP_PKEY_get_bits(Crypt::OpenSSL3::PKey pkey)
4785              
4786             int EVP_PKEY_get_security_bits(Crypt::OpenSSL3::PKey pkey)
4787              
4788             bool EVP_PKEY_is_a(Crypt::OpenSSL3::PKey pkey, const char *name)
4789              
4790             bool EVP_PKEY_can_sign(Crypt::OpenSSL3::PKey pkey)
4791              
4792             void EVP_PKEY_type_names_list_all(Crypt::OpenSSL3::PKey pkey)
4793             PPCODE:
4794 0           PUTBACK;
4795 0           EVP_PKEY_type_names_do_all(pkey, EVP_name_callback, iTHX);
4796 0           SPAGAIN;
4797              
4798             const char *EVP_PKEY_get_type_name(Crypt::OpenSSL3::PKey key)
4799              
4800             const char *EVP_PKEY_get_description(Crypt::OpenSSL3::PKey key)
4801              
4802             Success EVP_PKEY_digestsign_supports_digest(Crypt::OpenSSL3::PKey pkey, const char *name, const char *propq)
4803             C_ARGS: pkey, NULL, name, propq
4804              
4805             NO_OUTPUT int EVP_PKEY_get_default_digest_name(Crypt::OpenSSL3::PKey pkey, OUTLIST SV* mdname)
4806             INIT:
4807 0           char* ptr = (char*)make_buffer(&mdname, 32);
4808             C_ARGS: pkey, ptr, 32
4809             POSTCALL:
4810 0 0         if (RETVAL > 0)
4811 0           set_buffer_length(mdname, strlen(SvPV_nolen(mdname)));
4812              
4813             NO_OUTPUT int EVP_PKEY_get_default_digest_nid(Crypt::OpenSSL3::PKey pkey, OUTLIST Crypt::OpenSSL3::NID pnid)
4814             POSTCALL:
4815 0 0         if (RETVAL <= 0)
4816 0           XSRETURN_UNDEF;
4817              
4818             int EVP_PKEY_get_field_type(Crypt::OpenSSL3::PKey pkey)
4819              
4820             int EVP_PKEY_get_ec_point_conv_form(Crypt::OpenSSL3::PKey pkey)
4821              
4822             NO_OUTPUT int EVP_PKEY_get_group_name(Crypt::OpenSSL3::PKey pkey, OUTLIST SV* name, size_t size = 32)
4823             INIT:
4824 0           char* ptr = (char*)make_buffer(&name, size);
4825             C_ARGS: pkey, ptr, size, &size
4826             POSTCALL:
4827 0 0         if (RETVAL)
4828 0           set_buffer_length(name, size);
4829              
4830             bool EVP_PKEY_set_encoded_public_key(Crypt::OpenSSL3::PKey pkey, const unsigned char *pub, size_t length(pub))
4831              
4832             NO_OUTPUT size_t EVP_PKEY_get_encoded_public_key(Crypt::OpenSSL3::PKey pkey, OUTLIST SV* result)
4833             INIT:
4834 0           unsigned char* ptr = NULL;
4835             C_ARGS: pkey, &ptr
4836             POSTCALL:
4837 0 0         result = RETVAL > 0 ? newSVpvn((char*)ptr, RETVAL) : &PL_sv_undef;
4838 0           OPENSSL_free(ptr);
4839              
4840             SV* EVP_PKEY_get_param(Crypt::OpenSSL3::PKey pkey, const char* name)
4841             CODE:
4842 0 0         GENERATE_GET_PARAM(EVP_PKEY, pkey, name)
    0          
    0          
    0          
4843             OUTPUT: RETVAL
4844              
4845             bool EVP_PKEY_get_int_param(Crypt::OpenSSL3::PKey pkey, const char *key_name, OUT int out)
4846              
4847             bool EVP_PKEY_get_size_t_param(Crypt::OpenSSL3::PKey pkey, const char *key_name, OUT size_t out)
4848              
4849             bool EVP_PKEY_get_bn_param(Crypt::OpenSSL3::PKey pkey, const char *key_name, OUT Crypt::OpenSSL3::BigNum bn)
4850              
4851             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)
4852              
4853             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)
4854              
4855             bool EVP_PKEY_set_params(Crypt::OpenSSL3::PKey ctx, PARAMS(EVP_PKEY) params = NULL)
4856              
4857             bool EVP_PKEY_set_int_param(Crypt::OpenSSL3::PKey pkey, const char *key_name, int in)
4858              
4859             bool EVP_PKEY_set_size_t_param(Crypt::OpenSSL3::PKey pkey, const char *key_name, size_t in)
4860              
4861             bool EVP_PKEY_set_bn_param(Crypt::OpenSSL3::PKey pkey, const char *key_name, Crypt::OpenSSL3::BigNum bn)
4862              
4863             bool EVP_PKEY_set_utf8_string_param(Crypt::OpenSSL3::PKey pkey, const char *key_name, const char *str)
4864              
4865             bool EVP_PKEY_set_octet_string_param(Crypt::OpenSSL3::PKey pkey, const char *key_name, const unsigned char *buf, size_t length(buf))
4866              
4867             Success EVP_PKEY_print_public(Crypt::OpenSSL3::PKey pkey, Crypt::OpenSSL3::BIO out, int indent = 0)
4868             C_ARGS: out, pkey, indent, NULL
4869              
4870             Success EVP_PKEY_print_private(Crypt::OpenSSL3::PKey pkey, Crypt::OpenSSL3::BIO out, int indent = 0)
4871             C_ARGS: out, pkey, indent, NULL
4872              
4873             Success EVP_PKEY_print_params(Crypt::OpenSSL3::PKey pkey, Crypt::OpenSSL3::BIO out, int indent = 0)
4874             C_ARGS: out, pkey, indent, NULL
4875              
4876             NO_OUTPUT int EVP_PKEY_todata(Crypt::OpenSSL3::PKey pkey, int selection, OUTLIST OSSL_PARAM* param)
4877             POSTCALL:
4878 0 0         if (!RETVAL)
4879 0           XSRETURN_UNDEF;
4880             CLEANUP:
4881 0           OSSL_PARAM_free(param);
4882              
4883              
4884             MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::PKey::Context PREFIX = EVP_PKEY_CTX_
4885              
4886              
4887             Crypt::OpenSSL3::PKey::Context EVP_PKEY_CTX_new(classname, Crypt::OpenSSL3::PKey pkey)
4888             C_ARGS: pkey, NULL
4889             POSTCALL:
4890 0 0         if (!RETVAL)
4891 0           XSRETURN_UNDEF;
4892              
4893             Crypt::OpenSSL3::PKey::Context EVP_PKEY_CTX_new_id(classname, Crypt::OpenSSL3::NID id)
4894             C_ARGS: id, NULL
4895             POSTCALL:
4896 0 0         if (!RETVAL)
4897 0           XSRETURN_UNDEF;
4898              
4899             Crypt::OpenSSL3::PKey::Context EVP_PKEY_CTX_new_from_name(classname, const char *name, const char *propquery = "")
4900             C_ARGS: NULL, name, propquery
4901             POSTCALL:
4902 2 50         if (!RETVAL)
4903 0           XSRETURN_UNDEF;
4904              
4905             Crypt::OpenSSL3::PKey::Context EVP_PKEY_CTX_new_from_pkey(classname, Crypt::OpenSSL3::PKey pkey, const char *propquery = "")
4906             C_ARGS: NULL, pkey, propquery
4907             POSTCALL:
4908 2 50         if (!RETVAL)
4909 0           XSRETURN_UNDEF;
4910              
4911             Crypt::OpenSSL3::PKey::Context EVP_PKEY_CTX_dup(Crypt::OpenSSL3::PKey::Context ctx)
4912              
4913             bool EVP_PKEY_CTX_set_params(Crypt::OpenSSL3::PKey::Context ctx, PARAMS(EVP_PKEY_CTX) params = NULL)
4914              
4915             SV* EVP_PKEY_CTX_get_param(Crypt::OpenSSL3::PKey::Context ctx, const char* name)
4916             CODE:
4917 0 0         GENERATE_GET_PARAM(EVP_PKEY_CTX, ctx, name)
    0          
    0          
    0          
4918             OUTPUT: RETVAL
4919              
4920             bool EVP_PKEY_CTX_is_a(Crypt::OpenSSL3::PKey::Context ctx, const char *keytype)
4921              
4922             #if OPENSSL_VERSION_PREREQ(3, 4)
4923             NO_OUTPUT int EVP_PKEY_CTX_get_algor(Crypt::OpenSSL3::PKey::Context ctx, OUTLIST Crypt::OpenSSL3::X509::Algorithm alg)
4924             INIT:
4925             alg = NULL;
4926             POSTCALL:
4927             if (!RETVAL)
4928             XSRETURN_UNDEF;
4929             #endif
4930              
4931             #if OPENSSL_VERSION_PREREQ(3, 4)
4932             bool EVP_PKEY_CTX_set_signature(Crypt::OpenSSL3::PKey::Context pctx, const unsigned char *sig, size_t length(sig))
4933             #endif
4934              
4935             Crypt::OpenSSL3::PKey EVP_PKEY_CTX_get_pkey(Crypt::OpenSSL3::PKey::Context ctx)
4936             INTERFACE: EVP_PKEY_CTX_get_pkey EVP_PKEY_CTX_get_peerkey
4937             POSTCALL:
4938 0 0         if (RETVAL)
4939 0           EVP_PKEY_up_ref(RETVAL);
4940             else
4941 0           XSRETURN_UNDEF;
4942              
4943              
4944             MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::PKey::Context PREFIX = EVP_PKEY_
4945              
4946             bool EVP_PKEY_fromdata_init(Crypt::OpenSSL3::PKey::Context ctx)
4947              
4948             NO_OUTPUT bool EVP_PKEY_fromdata(Crypt::OpenSSL3::PKey::Context ctx, OUTLIST Crypt::OpenSSL3::PKey ppkey, int selection, SV* params)
4949             C_ARGS: ctx, &ppkey, selection, params_for(EVP_PKEY_fromdata_settable(ctx, selection), params)
4950             POSTCALL:
4951 0 0         if (!RETVAL)
4952 0           XSRETURN_UNDEF;
4953              
4954             Success EVP_PKEY_keygen_init(Crypt::OpenSSL3::PKey::Context ctx)
4955              
4956             Success EVP_PKEY_paramgen_init(Crypt::OpenSSL3::PKey::Context ctx)
4957              
4958             NO_OUTPUT int EVP_PKEY_generate(Crypt::OpenSSL3::PKey::Context ctx, OUTLIST Crypt::OpenSSL3::PKey ppkey)
4959             INIT:
4960 2           ppkey = NULL;
4961             POSTCALL:
4962 2 50         if (RETVAL <= 0)
4963 0           XSRETURN_UNDEF;
4964              
4965             Success EVP_PKEY_encapsulate_init(Crypt::OpenSSL3::PKey::Context ctx)
4966             C_ARGS: ctx, NULL
4967              
4968             void EVP_PKEY_encapsulate(Crypt::OpenSSL3::PKey::Context ctx, OUTLIST SV* wrapped_key, OUTLIST SV* gen_key)
4969             CODE:
4970             size_t wrapped_length, gen_length;
4971 1 50         if (EVP_PKEY_encapsulate(ctx, NULL, &wrapped_length, NULL, &gen_length) != 1)
4972 0           XSRETURN_EMPTY;
4973              
4974 1           unsigned char* wrapped_ptr = make_buffer(&wrapped_key, wrapped_length);
4975 1           unsigned char* gen_ptr = make_buffer(&gen_key, gen_length);
4976              
4977 1 50         if (EVP_PKEY_encapsulate(ctx, wrapped_ptr, &wrapped_length, gen_ptr, &gen_length)) {
4978 1           set_buffer_length(wrapped_key, wrapped_length);
4979 1           set_buffer_length(gen_key, gen_length);
4980             } else {
4981 0           SvREFCNT_dec(wrapped_key);
4982 0           SvREFCNT_dec(gen_key);
4983 0           XSRETURN_EMPTY;
4984             }
4985              
4986             Success EVP_PKEY_decapsulate_init(Crypt::OpenSSL3::PKey::Context ctx)
4987             C_ARGS: ctx, NULL
4988              
4989             SV* EVP_PKEY_decapsulate(Crypt::OpenSSL3::PKey::Context ctx, const unsigned char *wrapped, size_t length(wrapped))
4990             CODE:
4991             size_t unwrapped_length;
4992 1           int result = EVP_PKEY_decapsulate(ctx, NULL, &unwrapped_length, wrapped, XSauto_length_of_wrapped);
4993 1 50         if (result == 1) {
4994 1           unsigned char* unwrapped_ptr = make_buffer(&RETVAL, unwrapped_length);
4995              
4996 1 50         if (EVP_PKEY_decapsulate(ctx, unwrapped_ptr, &unwrapped_length, wrapped, XSauto_length_of_wrapped) == 1)
4997 1           set_buffer_length(RETVAL, unwrapped_length);
4998             } else
4999 0           RETVAL = &PL_sv_undef;
5000             OUTPUT: RETVAL
5001              
5002             #if OPENSSL_VERSION_PREREQ(3, 2)
5003             Success EVP_PKEY_auth_encapsulate_init(Crypt::OpenSSL3::PKey::Context ctx, Crypt::OpenSSL3::PKey authpriv)
5004             C_ARGS: ctx, authpriv, NULL
5005              
5006             Success EVP_PKEY_auth_decapsulate_init(Crypt::OpenSSL3::PKey::Context ctx, Crypt::OpenSSL3::PKey authpub)
5007             C_ARGS: ctx, authpub, NULL
5008             #endif
5009              
5010             Success EVP_PKEY_encrypt_init(Crypt::OpenSSL3::PKey::Context ctx)
5011             C_ARGS: ctx, NULL
5012              
5013             SV* EVP_PKEY_encrypt(Crypt::OpenSSL3::PKey::Context ctx, const unsigned char *in, size_t length(in))
5014             CODE:
5015             size_t out_length;
5016 0           bool result = EVP_PKEY_encrypt(ctx, NULL, &out_length, in, XSauto_length_of_in);
5017 0 0         if (result == 1) {
5018 0           unsigned char* out_ptr = make_buffer(&RETVAL, out_length);
5019              
5020 0           result = EVP_PKEY_encrypt(ctx, out_ptr, &out_length, in, XSauto_length_of_in);
5021 0 0         if (result == 1)
5022 0           set_buffer_length(RETVAL, out_length);
5023             } else
5024 0           RETVAL = &PL_sv_undef;
5025             OUTPUT: RETVAL
5026              
5027             bool EVP_PKEY_decrypt_init(Crypt::OpenSSL3::PKey::Context ctx)
5028             C_ARGS: ctx, NULL
5029              
5030             SV* EVP_PKEY_decrypt(Crypt::OpenSSL3::PKey::Context ctx, const unsigned char *in, size_t length(in))
5031             CODE:
5032             size_t out_length;
5033 0 0         if (EVP_PKEY_decrypt(ctx, NULL, &out_length, in, XSauto_length_of_in) == 1) {
5034 0           unsigned char* out_ptr = make_buffer(&RETVAL, out_length);
5035              
5036 0 0         if (EVP_PKEY_decrypt(ctx, out_ptr, &out_length, in, XSauto_length_of_in) == 1)
5037 0           set_buffer_length(RETVAL, out_length);
5038             } else
5039 0           RETVAL = &PL_sv_undef;
5040             OUTPUT: RETVAL
5041              
5042             bool EVP_PKEY_derive_init(Crypt::OpenSSL3::PKey::Context ctx)
5043             C_ARGS: ctx, NULL
5044              
5045             bool EVP_PKEY_derive_set_peer(Crypt::OpenSSL3::PKey::Context ctx, Crypt::OpenSSL3::PKey peer, bool validate_peer = false)
5046              
5047             SV* EVP_PKEY_derive(Crypt::OpenSSL3::PKey::Context ctx)
5048             CODE:
5049             size_t key_length;
5050 0 0         if (EVP_PKEY_derive(ctx, NULL, &key_length) == 1) {
5051 0           unsigned char* key_ptr = make_buffer(&RETVAL, key_length);
5052              
5053 0 0         if (EVP_PKEY_derive(ctx, key_ptr, &key_length) == 1)
5054 0           set_buffer_length(RETVAL, key_length);
5055             } else
5056 0           RETVAL = &PL_sv_undef;
5057             OUTPUT: RETVAL
5058              
5059             Success EVP_PKEY_sign_init(Crypt::OpenSSL3::PKey::Context ctx, Crypt::OpenSSL3::Signature type = NULL, CTX_PARAMS(EVP_SIGNATURE) params = NULL)
5060              
5061             SV* EVP_PKEY_sign(Crypt::OpenSSL3::PKey::Context ctx, const unsigned char *tbs, size_t length(tbs))
5062             CODE:
5063             size_t sig_length;
5064 0 0         if (EVP_PKEY_sign(ctx, NULL, &sig_length, tbs, XSauto_length_of_tbs) == 1) {
5065 0           unsigned char* sig_ptr = make_buffer(&RETVAL, sig_length);
5066              
5067 0 0         if (EVP_PKEY_sign(ctx, sig_ptr, &sig_length, tbs, XSauto_length_of_tbs) == 1)
5068 0           set_buffer_length(RETVAL, sig_length);
5069             } else
5070 0           RETVAL = &PL_sv_undef;
5071             OUTPUT: RETVAL
5072              
5073             Success EVP_PKEY_verify_init(Crypt::OpenSSL3::PKey::Context ctx, Crypt::OpenSSL3::Signature type = NULL, CTX_PARAMS(EVP_SIGNATURE) params = NULL)
5074              
5075             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))
5076              
5077             #if OPENSSL_VERSION_PREREQ(3, 4)
5078             Success EVP_PKEY_sign_message_init(Crypt::OpenSSL3::PKey::Context ctx, Crypt::OpenSSL3::Signature type = NULL, CTX_PARAMS(EVP_SIGNATURE) params = NULL)
5079              
5080             Success EVP_PKEY_sign_message_update(Crypt::OpenSSL3::PKey::Context ctx, unsigned char *in, size_t length(in))
5081              
5082             SV* EVP_PKEY_sign_message_final(Crypt::OpenSSL3::PKey::Context ctx)
5083             CODE:
5084             size_t sigsize;
5085             if (EVP_PKEY_sign_message_final(ctx, NULL, &sigsize) == 1) {
5086             unsigned char* ptr = make_buffer(&RETVAL, sigsize);
5087             if (EVP_PKEY_sign_message_final(ctx, ptr, &sigsize) == 1)
5088             set_buffer_length(RETVAL, sigsize);
5089             } else
5090             RETVAL = &PL_sv_undef;
5091             OUTPUT: RETVAL
5092              
5093             Success EVP_PKEY_verify_message_init(Crypt::OpenSSL3::PKey::Context ctx, Crypt::OpenSSL3::Signature type = NULL, CTX_PARAMS(EVP_SIGNATURE) params = NULL)
5094              
5095             Success EVP_PKEY_verify_message_update(Crypt::OpenSSL3::PKey::Context ctx, unsigned char *in, size_t length(in))
5096              
5097             Success EVP_PKEY_verify_message_final(Crypt::OpenSSL3::PKey::Context ctx)
5098              
5099             #endif
5100              
5101              
5102             MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::HPKE PREFIX = OSSL_HPKE_
5103              
5104              
5105             BOOT:
5106             {
5107             #if OPENSSL_VERSION_PREREQ(3, 2)
5108             HV* stash = gv_stashpvs("Crypt::OpenSSL3::HPKE", GV_ADD | GV_ADDMULTI);
5109             CONSTANT2(OSSL_HPKE_, KEM_ID_P256);
5110             CONSTANT2(OSSL_HPKE_, KEM_ID_P384);
5111             CONSTANT2(OSSL_HPKE_, KEM_ID_P521);
5112             CONSTANT2(OSSL_HPKE_, KEM_ID_X25519);
5113             CONSTANT2(OSSL_HPKE_, KEM_ID_X448);
5114              
5115             CONSTANT2(OSSL_HPKE_, KDF_ID_HKDF_SHA256);
5116             CONSTANT2(OSSL_HPKE_, KDF_ID_HKDF_SHA384);
5117             CONSTANT2(OSSL_HPKE_, KDF_ID_HKDF_SHA512);
5118              
5119             CONSTANT2(OSSL_HPKE_, AEAD_ID_AES_GCM_128);
5120             CONSTANT2(OSSL_HPKE_, AEAD_ID_AES_GCM_256);
5121             CONSTANT2(OSSL_HPKE_, AEAD_ID_CHACHA_POLY1305);
5122             CONSTANT2(OSSL_HPKE_, AEAD_ID_EXPORTONLY);
5123              
5124             CONSTANT2(OSSL_HPKE_, ROLE_SENDER);
5125             CONSTANT2(OSSL_HPKE_, ROLE_RECEIVER);
5126              
5127             CONSTANT2(OSSL_HPKE_, MODE_BASE);
5128             CONSTANT2(OSSL_HPKE_, MODE_PSK);
5129             CONSTANT2(OSSL_HPKE_, MODE_AUTH);
5130             CONSTANT2(OSSL_HPKE_, MODE_PSKAUTH);
5131              
5132             CONSTANT2(OSSL_HPKE_, MAX_PARMLEN);
5133             CONSTANT2(OSSL_HPKE_, MIN_PSKLEN);
5134             CONSTANT2(OSSL_HPKE_, MAX_INFOLEN);
5135             #endif
5136             }
5137              
5138             #if OPENSSL_VERSION_PREREQ(3, 2)
5139              
5140             Crypt::OpenSSL3::HPKE OSSL_HPKE_new(class, unsigned short kem, unsigned short kdf, unsigned short aead)
5141             CODE:
5142             RETVAL = safemalloc(sizeof(OSSL_HPKE_SUITE));
5143             RETVAL->kem_id = kem;
5144             RETVAL->kdf_id = kdf;
5145             RETVAL->aead_id = aead;
5146             OUTPUT: RETVAL
5147              
5148             Crypt::OpenSSL3::HPKE OSSL_HPKE_from_string(class, const char *str)
5149             CODE:
5150             RETVAL = safemalloc(sizeof(OSSL_HPKE_SUITE));
5151             if (!OSSL_HPKE_str2suite(str, RETVAL)) {
5152             Safefree(RETVAL);
5153             XSRETURN_UNDEF;
5154             }
5155             OUTPUT: RETVAL
5156              
5157             Crypt::OpenSSL3::HPKE OSSL_HPKE_default(class)
5158             CODE:
5159             RETVAL = safemalloc(sizeof(OSSL_HPKE_SUITE));
5160             *RETVAL = (OSSL_HPKE_SUITE)OSSL_HPKE_SUITE_DEFAULT;
5161             OUTPUT: RETVAL
5162              
5163             Bool OSSL_HPKE_check(Crypt::OpenSSL3::HPKE suite)
5164             C_ARGS: *suite
5165              
5166             size_t OSSL_HPKE_get_ciphertext_size(Crypt::OpenSSL3::HPKE suite, size_t clearlen)
5167             C_ARGS: *suite, clearlen
5168              
5169             size_t OSSL_HPKE_get_public_encap_size(Crypt::OpenSSL3::HPKE suite)
5170             C_ARGS: *suite
5171              
5172             size_t OSSL_HPKE_get_recommended_ikmelen(Crypt::OpenSSL3::HPKE suite);
5173             C_ARGS: *suite
5174              
5175             SV* OSSL_HPKE_keygen(Crypt::OpenSSL3::HPKE suite, OUTLIST Crypt::OpenSSL3::PKey priv, const char *propq = NULL)
5176             CODE:
5177             size_t pub_len = OSSL_HPKE_get_public_encap_size(*suite);
5178             unsigned char* pub = make_buffer(&RETVAL, pub_len);
5179             if (OSSL_HPKE_keygen(*suite, pub, &pub_len, &priv, NULL, 0, NULL, propq))
5180             set_buffer_length(RETVAL, pub_len);
5181             else {
5182             SvREFCNT_dec(RETVAL);
5183             XSRETURN_EMPTY;
5184             }
5185             OUTPUT: RETVAL
5186              
5187             SV* OSSL_HPKE_suite(Crypt::OpenSSL3::HPKE suite)
5188             CODE:
5189             RETVAL = newSVpvn((const char*)suite, sizeof *suite);
5190             OUTPUT: RETVAL
5191              
5192             unsigned short OSSL_HPKE_kem_id(Crypt::OpenSSL3::HPKE suite)
5193              
5194             unsigned short OSSL_HPKE_kdf_id(Crypt::OpenSSL3::HPKE suite)
5195              
5196             unsigned short OSSL_HPKE_aead_id(Crypt::OpenSSL3::HPKE suite)
5197              
5198             void OSSL_HPKE_get_grease_value(Crypt::OpenSSL3::HPKE suite, OUTLIST SV* enc, OUTLIST SV* ct, size_t pt_length, const char *propq = NULL)
5199             CODE:
5200             size_t enc_length = OSSL_HPKE_get_public_encap_size(*suite);
5201             unsigned char* enc_ptr = make_buffer(&enc, enc_length);
5202             size_t ct_length = OSSL_HPKE_get_ciphertext_size(*suite, pt_length);
5203             unsigned char* ct_ptr = make_buffer(&ct, ct_length);
5204             int retval = OSSL_HPKE_get_grease_value(suite, suite, enc_ptr, &enc_length, ct_ptr, ct_length, NULL, propq);
5205             if (retval) {
5206             set_buffer_length(enc, enc_length);
5207             set_buffer_length(ct, ct_length);
5208             }
5209             else {
5210             SvREFCNT_dec(enc);
5211             SvREFCNT_dec(ct);
5212             XSRETURN_EMPTY;
5213             }
5214              
5215             #endif
5216              
5217              
5218             MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::HPKE::Context PREFIX = OSSL_HPKE_
5219              
5220             #if OPENSSL_VERSION_PREREQ(3, 2)
5221              
5222             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))
5223             CODE:
5224             size_t enc_length = OSSL_HPKE_get_public_encap_size(hpke->suite);
5225             unsigned char* enc_ptr = make_buffer(&RETVAL, enc_length);
5226             if (OSSL_HPKE_encap(hpke->context, enc_ptr, &enc_length, pub, XSauto_length_of_pub, info, XSauto_length_of_info))
5227             set_buffer_length(RETVAL, enc_length);
5228             OUTPUT: RETVAL
5229              
5230             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))
5231             CODE:
5232             size_t enc_length = OSSL_HPKE_get_ciphertext_size(hpke->suite, XSauto_length_of_pt);
5233             unsigned char* enc_ptr = make_buffer(&RETVAL, enc_length);
5234             if (OSSL_HPKE_seal(hpke->context, enc_ptr, &enc_length, aad, XSauto_length_of_aad, pt, XSauto_length_of_pt))
5235             set_buffer_length(RETVAL, enc_length);
5236             OUTPUT: RETVAL
5237              
5238             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))
5239             C_ARGS: hpke->context, enc, XSauto_length_of_enc, recippriv, info, XSauto_length_of_info
5240              
5241             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))
5242             CODE:
5243             size_t pt_length = XSauto_length_of_ct;
5244             unsigned char* pt_ptr = make_buffer(&RETVAL, pt_length);
5245             if (OSSL_HPKE_open(hpke->context, pt_ptr, &pt_length, aad, XSauto_length_of_aad, ct, XSauto_length_of_ct))
5246             set_buffer_length(RETVAL, pt_length);
5247             OUTPUT: RETVAL
5248              
5249             SV* OSSL_HPKE_export(Crypt::OpenSSL3::HPKE::Context hpke, size_t secret_length, const unsigned char *label, size_t length(label))
5250             CODE:
5251             unsigned char* secret = make_buffer(&RETVAL, secret_length);
5252             if (OSSL_HPKE_export(hpke->context, secret, secret_length, label, XSauto_length_of_label))
5253             set_buffer_length(RETVAL, secret_length);
5254             OUTPUT: RETVAL
5255              
5256             #endif
5257              
5258              
5259             MODULE = Crypt::OpenSSL3 PACKAGE = Crypt::OpenSSL3::HPKE::Context PREFIX = OSSL_HPKE_CTX_
5260              
5261             #if OPENSSL_VERSION_PREREQ(3, 2)
5262              
5263             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)
5264             CODE:
5265             OSSL_HPKE_CTX* ctx = OSSL_HPKE_CTX_new(mode, *suite, role, NULL, propq);
5266             if (!ctx)
5267             XSRETURN_UNDEF;
5268             RETVAL = safemalloc(sizeof(HPKE));
5269             RETVAL->suite = *suite;
5270             RETVAL->context = ctx;
5271             OUTPUT: RETVAL
5272              
5273             bool OSSL_HPKE_CTX_set_authpriv(Crypt::OpenSSL3::HPKE::Context hpke, Crypt::OpenSSL3::PKey priv)
5274             C_ARGS: hpke->context, priv
5275              
5276             bool OSSL_HPKE_CTX_set_authpub(Crypt::OpenSSL3::HPKE::Context hpke, unsigned char *input, size_t length(input))
5277             INTERFACE: OSSL_HPKE_CTX_set_authpub OSSL_HPKE_CTX_set_ikme
5278             C_ARGS: hpke->context, input, XSauto_length_of_input
5279              
5280             bool OSSL_HPKE_CTX_set_psk(Crypt::OpenSSL3::HPKE::Context hpke, const char *pskid, const unsigned char *psk, size_t length(psk))
5281             C_ARGS: hpke->context, pskid, psk, XSauto_length_of_psk
5282              
5283             NO_OUTPUT int OSSL_HPKE_CTX_get_seq(Crypt::OpenSSL3::HPKE::Context hpke, OUTLIST uint64_t seq)
5284             C_ARGS: hpke->context, &seq
5285             POSTCALL:
5286             if (!RETVAL)
5287             XSRETURN_UNDEF;
5288              
5289             bool OSSL_HPKE_CTX_set_seq(Crypt::OpenSSL3::HPKE::Context hpke, uint64_t seq)
5290             C_ARGS: hpke->context, seq
5291              
5292             Bool CLONE_SKIP(...)
5293              
5294             #endif