@crossbind/port-openssl-linuxmusl 2.0.0-beta.65 → 2.0.0-beta.67

package/dist/prebuilt/linuxmusl-x64-mt-release/include/openssl/pkcs7.h

@@ -71,9 +71,30 @@ typedef struct pkcs7_signer_info_st {
 SKM_DEFINE_STACK_OF_INTERNAL(PKCS7_SIGNER_INFO, PKCS7_SIGNER_INFO, PKCS7_SIGNER_INFO)
 #define sk_PKCS7_SIGNER_INFO_num(sk) OPENSSL_sk_num(ossl_check_const_PKCS7_SIGNER_INFO_sk_type(sk))
 #define sk_PKCS7_SIGNER_INFO_value(sk, idx) ((PKCS7_SIGNER_INFO *)OPENSSL_sk_value(ossl_check_const_PKCS7_SIGNER_INFO_sk_type(sk), (idx)))
-#define sk_PKCS7_SIGNER_INFO_new(cmp) ((STACK_OF(PKCS7_SIGNER_INFO) *)OPENSSL_sk_set_cmp_thunks(OPENSSL_sk_new(ossl_check_PKCS7_SIGNER_INFO_compfunc_type(cmp)), sk_PKCS7_SIGNER_INFO_cmpfunc_thunk))
-#define sk_PKCS7_SIGNER_INFO_new_null() ((STACK_OF(PKCS7_SIGNER_INFO) *)OPENSSL_sk_set_thunks(OPENSSL_sk_new_null(), sk_PKCS7_SIGNER_INFO_freefunc_thunk))
-#define sk_PKCS7_SIGNER_INFO_new_reserve(cmp, n) ((STACK_OF(PKCS7_SIGNER_INFO) *)OPENSSL_sk_set_cmp_thunks(OPENSSL_sk_new_reserve(ossl_check_PKCS7_SIGNER_INFO_compfunc_type(cmp), (n)), sk_PKCS7_SIGNER_INFO_cmpfunc_thunk))
+#define sk_PKCS7_SIGNER_INFO_new(cmp) \
+    ((STACK_OF(PKCS7_SIGNER_INFO) *)OPENSSL_sk_set_thunks( \
+        OPENSSL_sk_set_copy_thunks( \
+            OPENSSL_sk_set_cmp_thunks( \
+                OPENSSL_sk_new(ossl_check_PKCS7_SIGNER_INFO_compfunc_type(cmp)), \
+                sk_PKCS7_SIGNER_INFO_cmpfunc_thunk), \
+            sk_PKCS7_SIGNER_INFO_copyfunc_thunk), \
+        sk_PKCS7_SIGNER_INFO_freefunc_thunk))
+#define sk_PKCS7_SIGNER_INFO_new_null() \
+    ((STACK_OF(PKCS7_SIGNER_INFO) *)OPENSSL_sk_set_thunks( \
+        OPENSSL_sk_set_copy_thunks( \
+            OPENSSL_sk_set_cmp_thunks( \
+                OPENSSL_sk_new_null(), \
+                sk_PKCS7_SIGNER_INFO_cmpfunc_thunk), \
+            sk_PKCS7_SIGNER_INFO_copyfunc_thunk), \
+        sk_PKCS7_SIGNER_INFO_freefunc_thunk))
+#define sk_PKCS7_SIGNER_INFO_new_reserve(cmp, n) \
+    ((STACK_OF(PKCS7_SIGNER_INFO) *)OPENSSL_sk_set_thunks( \
+        OPENSSL_sk_set_copy_thunks( \
+            OPENSSL_sk_set_cmp_thunks( \
+                OPENSSL_sk_new_reserve(ossl_check_PKCS7_SIGNER_INFO_compfunc_type(cmp), (n)), \
+                sk_PKCS7_SIGNER_INFO_cmpfunc_thunk), \
+            sk_PKCS7_SIGNER_INFO_copyfunc_thunk), \
+        sk_PKCS7_SIGNER_INFO_freefunc_thunk))
 #define sk_PKCS7_SIGNER_INFO_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_PKCS7_SIGNER_INFO_sk_type(sk), (n))
 #define sk_PKCS7_SIGNER_INFO_free(sk) OPENSSL_sk_free(ossl_check_PKCS7_SIGNER_INFO_sk_type(sk))
 #define sk_PKCS7_SIGNER_INFO_zero(sk) OPENSSL_sk_zero(ossl_check_PKCS7_SIGNER_INFO_sk_type(sk))
@@ -91,8 +112,25 @@ SKM_DEFINE_STACK_OF_INTERNAL(PKCS7_SIGNER_INFO, PKCS7_SIGNER_INFO, PKCS7_SIGNER_
 #define sk_PKCS7_SIGNER_INFO_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_PKCS7_SIGNER_INFO_sk_type(sk), ossl_check_PKCS7_SIGNER_INFO_type(ptr), pnum)
 #define sk_PKCS7_SIGNER_INFO_sort(sk) OPENSSL_sk_sort(ossl_check_PKCS7_SIGNER_INFO_sk_type(sk))
 #define sk_PKCS7_SIGNER_INFO_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_PKCS7_SIGNER_INFO_sk_type(sk))
-#define sk_PKCS7_SIGNER_INFO_dup(sk) ((STACK_OF(PKCS7_SIGNER_INFO) *)OPENSSL_sk_dup(ossl_check_const_PKCS7_SIGNER_INFO_sk_type(sk)))
-#define sk_PKCS7_SIGNER_INFO_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(PKCS7_SIGNER_INFO) *)OPENSSL_sk_deep_copy(ossl_check_const_PKCS7_SIGNER_INFO_sk_type(sk), ossl_check_PKCS7_SIGNER_INFO_copyfunc_type(copyfunc), ossl_check_PKCS7_SIGNER_INFO_freefunc_type(freefunc)))
+#define sk_PKCS7_SIGNER_INFO_dup(sk) \
+    ((STACK_OF(PKCS7_SIGNER_INFO) *)OPENSSL_sk_set_thunks( \
+        OPENSSL_sk_set_copy_thunks( \
+            OPENSSL_sk_set_cmp_thunks( \
+                OPENSSL_sk_dup(ossl_check_const_PKCS7_SIGNER_INFO_sk_type(sk)), \
+                sk_PKCS7_SIGNER_INFO_cmpfunc_thunk), \
+            sk_PKCS7_SIGNER_INFO_copyfunc_thunk), \
+        sk_PKCS7_SIGNER_INFO_freefunc_thunk))
+#define sk_PKCS7_SIGNER_INFO_deep_copy(sk, copyfunc, freefunc) \
+    ((STACK_OF(PKCS7_SIGNER_INFO) *)OPENSSL_sk_set_thunks( \
+        OPENSSL_sk_set_copy_thunks( \
+            OPENSSL_sk_set_cmp_thunks( \
+                OPENSSL_sk_deep_copy( \
+                    ossl_check_const_PKCS7_SIGNER_INFO_sk_type(sk), \
+                    ossl_check_PKCS7_SIGNER_INFO_copyfunc_type(copyfunc), \
+                    ossl_check_PKCS7_SIGNER_INFO_freefunc_type(freefunc)), \
+                sk_PKCS7_SIGNER_INFO_cmpfunc_thunk), \
+            sk_PKCS7_SIGNER_INFO_copyfunc_thunk), \
+        sk_PKCS7_SIGNER_INFO_freefunc_thunk))
 #define sk_PKCS7_SIGNER_INFO_set_cmp_func(sk, cmp) ((sk_PKCS7_SIGNER_INFO_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_PKCS7_SIGNER_INFO_sk_type(sk), ossl_check_PKCS7_SIGNER_INFO_compfunc_type(cmp)))
 
 /* clang-format on */
@@ -109,9 +147,30 @@ typedef struct pkcs7_recip_info_st {
 SKM_DEFINE_STACK_OF_INTERNAL(PKCS7_RECIP_INFO, PKCS7_RECIP_INFO, PKCS7_RECIP_INFO)
 #define sk_PKCS7_RECIP_INFO_num(sk) OPENSSL_sk_num(ossl_check_const_PKCS7_RECIP_INFO_sk_type(sk))
 #define sk_PKCS7_RECIP_INFO_value(sk, idx) ((PKCS7_RECIP_INFO *)OPENSSL_sk_value(ossl_check_const_PKCS7_RECIP_INFO_sk_type(sk), (idx)))
-#define sk_PKCS7_RECIP_INFO_new(cmp) ((STACK_OF(PKCS7_RECIP_INFO) *)OPENSSL_sk_set_cmp_thunks(OPENSSL_sk_new(ossl_check_PKCS7_RECIP_INFO_compfunc_type(cmp)), sk_PKCS7_RECIP_INFO_cmpfunc_thunk))
-#define sk_PKCS7_RECIP_INFO_new_null() ((STACK_OF(PKCS7_RECIP_INFO) *)OPENSSL_sk_set_thunks(OPENSSL_sk_new_null(), sk_PKCS7_RECIP_INFO_freefunc_thunk))
-#define sk_PKCS7_RECIP_INFO_new_reserve(cmp, n) ((STACK_OF(PKCS7_RECIP_INFO) *)OPENSSL_sk_set_cmp_thunks(OPENSSL_sk_new_reserve(ossl_check_PKCS7_RECIP_INFO_compfunc_type(cmp), (n)), sk_PKCS7_RECIP_INFO_cmpfunc_thunk))
+#define sk_PKCS7_RECIP_INFO_new(cmp) \
+    ((STACK_OF(PKCS7_RECIP_INFO) *)OPENSSL_sk_set_thunks( \
+        OPENSSL_sk_set_copy_thunks( \
+            OPENSSL_sk_set_cmp_thunks( \
+                OPENSSL_sk_new(ossl_check_PKCS7_RECIP_INFO_compfunc_type(cmp)), \
+                sk_PKCS7_RECIP_INFO_cmpfunc_thunk), \
+            sk_PKCS7_RECIP_INFO_copyfunc_thunk), \
+        sk_PKCS7_RECIP_INFO_freefunc_thunk))
+#define sk_PKCS7_RECIP_INFO_new_null() \
+    ((STACK_OF(PKCS7_RECIP_INFO) *)OPENSSL_sk_set_thunks( \
+        OPENSSL_sk_set_copy_thunks( \
+            OPENSSL_sk_set_cmp_thunks( \
+                OPENSSL_sk_new_null(), \
+                sk_PKCS7_RECIP_INFO_cmpfunc_thunk), \
+            sk_PKCS7_RECIP_INFO_copyfunc_thunk), \
+        sk_PKCS7_RECIP_INFO_freefunc_thunk))
+#define sk_PKCS7_RECIP_INFO_new_reserve(cmp, n) \
+    ((STACK_OF(PKCS7_RECIP_INFO) *)OPENSSL_sk_set_thunks( \
+        OPENSSL_sk_set_copy_thunks( \
+            OPENSSL_sk_set_cmp_thunks( \
+                OPENSSL_sk_new_reserve(ossl_check_PKCS7_RECIP_INFO_compfunc_type(cmp), (n)), \
+                sk_PKCS7_RECIP_INFO_cmpfunc_thunk), \
+            sk_PKCS7_RECIP_INFO_copyfunc_thunk), \
+        sk_PKCS7_RECIP_INFO_freefunc_thunk))
 #define sk_PKCS7_RECIP_INFO_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_PKCS7_RECIP_INFO_sk_type(sk), (n))
 #define sk_PKCS7_RECIP_INFO_free(sk) OPENSSL_sk_free(ossl_check_PKCS7_RECIP_INFO_sk_type(sk))
 #define sk_PKCS7_RECIP_INFO_zero(sk) OPENSSL_sk_zero(ossl_check_PKCS7_RECIP_INFO_sk_type(sk))
@@ -129,8 +188,25 @@ SKM_DEFINE_STACK_OF_INTERNAL(PKCS7_RECIP_INFO, PKCS7_RECIP_INFO, PKCS7_RECIP_INF
 #define sk_PKCS7_RECIP_INFO_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_PKCS7_RECIP_INFO_sk_type(sk), ossl_check_PKCS7_RECIP_INFO_type(ptr), pnum)
 #define sk_PKCS7_RECIP_INFO_sort(sk) OPENSSL_sk_sort(ossl_check_PKCS7_RECIP_INFO_sk_type(sk))
 #define sk_PKCS7_RECIP_INFO_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_PKCS7_RECIP_INFO_sk_type(sk))
-#define sk_PKCS7_RECIP_INFO_dup(sk) ((STACK_OF(PKCS7_RECIP_INFO) *)OPENSSL_sk_dup(ossl_check_const_PKCS7_RECIP_INFO_sk_type(sk)))
-#define sk_PKCS7_RECIP_INFO_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(PKCS7_RECIP_INFO) *)OPENSSL_sk_deep_copy(ossl_check_const_PKCS7_RECIP_INFO_sk_type(sk), ossl_check_PKCS7_RECIP_INFO_copyfunc_type(copyfunc), ossl_check_PKCS7_RECIP_INFO_freefunc_type(freefunc)))
+#define sk_PKCS7_RECIP_INFO_dup(sk) \
+    ((STACK_OF(PKCS7_RECIP_INFO) *)OPENSSL_sk_set_thunks( \
+        OPENSSL_sk_set_copy_thunks( \
+            OPENSSL_sk_set_cmp_thunks( \
+                OPENSSL_sk_dup(ossl_check_const_PKCS7_RECIP_INFO_sk_type(sk)), \
+                sk_PKCS7_RECIP_INFO_cmpfunc_thunk), \
+            sk_PKCS7_RECIP_INFO_copyfunc_thunk), \
+        sk_PKCS7_RECIP_INFO_freefunc_thunk))
+#define sk_PKCS7_RECIP_INFO_deep_copy(sk, copyfunc, freefunc) \
+    ((STACK_OF(PKCS7_RECIP_INFO) *)OPENSSL_sk_set_thunks( \
+        OPENSSL_sk_set_copy_thunks( \
+            OPENSSL_sk_set_cmp_thunks( \
+                OPENSSL_sk_deep_copy( \
+                    ossl_check_const_PKCS7_RECIP_INFO_sk_type(sk), \
+                    ossl_check_PKCS7_RECIP_INFO_copyfunc_type(copyfunc), \
+                    ossl_check_PKCS7_RECIP_INFO_freefunc_type(freefunc)), \
+                sk_PKCS7_RECIP_INFO_cmpfunc_thunk), \
+            sk_PKCS7_RECIP_INFO_copyfunc_thunk), \
+        sk_PKCS7_RECIP_INFO_freefunc_thunk))
 #define sk_PKCS7_RECIP_INFO_set_cmp_func(sk, cmp) ((sk_PKCS7_RECIP_INFO_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_PKCS7_RECIP_INFO_sk_type(sk), ossl_check_PKCS7_RECIP_INFO_compfunc_type(cmp)))
 
 /* clang-format on */
@@ -138,6 +214,7 @@ SKM_DEFINE_STACK_OF_INTERNAL(PKCS7_RECIP_INFO, PKCS7_RECIP_INFO, PKCS7_RECIP_INF
 typedef struct pkcs7_signed_st {
     ASN1_INTEGER *version; /* version 1 */
     STACK_OF(X509_ALGOR) *md_algs; /* md used */
+    /* untrusted certificates for chain building, may include signer certs: */
     STACK_OF(X509) *cert; /* [ 0 ] */ /* name should be 'certificates' */
     STACK_OF(X509_CRL) *crl; /* [ 1 ] */ /* name should be 'crls' */
     STACK_OF(PKCS7_SIGNER_INFO) *signer_info;
@@ -165,6 +242,7 @@ typedef struct pkcs7_enveloped_st {
 typedef struct pkcs7_signedandenveloped_st {
     ASN1_INTEGER *version; /* version 1 */
     STACK_OF(X509_ALGOR) *md_algs; /* md used */
+    /* untrusted certificates for chain building, may include signer certs: */
     STACK_OF(X509) *cert; /* [ 0 ] */ /* name should be 'certificates' */
     STACK_OF(X509_CRL) *crl; /* [ 1 ] */ /* name should be 'crls' */
     STACK_OF(PKCS7_SIGNER_INFO) *signer_info;
@@ -225,9 +303,30 @@ typedef struct pkcs7_st {
 SKM_DEFINE_STACK_OF_INTERNAL(PKCS7, PKCS7, PKCS7)
 #define sk_PKCS7_num(sk) OPENSSL_sk_num(ossl_check_const_PKCS7_sk_type(sk))
 #define sk_PKCS7_value(sk, idx) ((PKCS7 *)OPENSSL_sk_value(ossl_check_const_PKCS7_sk_type(sk), (idx)))
-#define sk_PKCS7_new(cmp) ((STACK_OF(PKCS7) *)OPENSSL_sk_set_cmp_thunks(OPENSSL_sk_new(ossl_check_PKCS7_compfunc_type(cmp)), sk_PKCS7_cmpfunc_thunk))
-#define sk_PKCS7_new_null() ((STACK_OF(PKCS7) *)OPENSSL_sk_set_thunks(OPENSSL_sk_new_null(), sk_PKCS7_freefunc_thunk))
-#define sk_PKCS7_new_reserve(cmp, n) ((STACK_OF(PKCS7) *)OPENSSL_sk_set_cmp_thunks(OPENSSL_sk_new_reserve(ossl_check_PKCS7_compfunc_type(cmp), (n)), sk_PKCS7_cmpfunc_thunk))
+#define sk_PKCS7_new(cmp) \
+    ((STACK_OF(PKCS7) *)OPENSSL_sk_set_thunks( \
+        OPENSSL_sk_set_copy_thunks( \
+            OPENSSL_sk_set_cmp_thunks( \
+                OPENSSL_sk_new(ossl_check_PKCS7_compfunc_type(cmp)), \
+                sk_PKCS7_cmpfunc_thunk), \
+            sk_PKCS7_copyfunc_thunk), \
+        sk_PKCS7_freefunc_thunk))
+#define sk_PKCS7_new_null() \
+    ((STACK_OF(PKCS7) *)OPENSSL_sk_set_thunks( \
+        OPENSSL_sk_set_copy_thunks( \
+            OPENSSL_sk_set_cmp_thunks( \
+                OPENSSL_sk_new_null(), \
+                sk_PKCS7_cmpfunc_thunk), \
+            sk_PKCS7_copyfunc_thunk), \
+        sk_PKCS7_freefunc_thunk))
+#define sk_PKCS7_new_reserve(cmp, n) \
+    ((STACK_OF(PKCS7) *)OPENSSL_sk_set_thunks( \
+        OPENSSL_sk_set_copy_thunks( \
+            OPENSSL_sk_set_cmp_thunks( \
+                OPENSSL_sk_new_reserve(ossl_check_PKCS7_compfunc_type(cmp), (n)), \
+                sk_PKCS7_cmpfunc_thunk), \
+            sk_PKCS7_copyfunc_thunk), \
+        sk_PKCS7_freefunc_thunk))
 #define sk_PKCS7_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_PKCS7_sk_type(sk), (n))
 #define sk_PKCS7_free(sk) OPENSSL_sk_free(ossl_check_PKCS7_sk_type(sk))
 #define sk_PKCS7_zero(sk) OPENSSL_sk_zero(ossl_check_PKCS7_sk_type(sk))
@@ -245,8 +344,25 @@ SKM_DEFINE_STACK_OF_INTERNAL(PKCS7, PKCS7, PKCS7)
 #define sk_PKCS7_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_PKCS7_sk_type(sk), ossl_check_PKCS7_type(ptr), pnum)
 #define sk_PKCS7_sort(sk) OPENSSL_sk_sort(ossl_check_PKCS7_sk_type(sk))
 #define sk_PKCS7_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_PKCS7_sk_type(sk))
-#define sk_PKCS7_dup(sk) ((STACK_OF(PKCS7) *)OPENSSL_sk_dup(ossl_check_const_PKCS7_sk_type(sk)))
-#define sk_PKCS7_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(PKCS7) *)OPENSSL_sk_deep_copy(ossl_check_const_PKCS7_sk_type(sk), ossl_check_PKCS7_copyfunc_type(copyfunc), ossl_check_PKCS7_freefunc_type(freefunc)))
+#define sk_PKCS7_dup(sk) \
+    ((STACK_OF(PKCS7) *)OPENSSL_sk_set_thunks( \
+        OPENSSL_sk_set_copy_thunks( \
+            OPENSSL_sk_set_cmp_thunks( \
+                OPENSSL_sk_dup(ossl_check_const_PKCS7_sk_type(sk)), \
+                sk_PKCS7_cmpfunc_thunk), \
+            sk_PKCS7_copyfunc_thunk), \
+        sk_PKCS7_freefunc_thunk))
+#define sk_PKCS7_deep_copy(sk, copyfunc, freefunc) \
+    ((STACK_OF(PKCS7) *)OPENSSL_sk_set_thunks( \
+        OPENSSL_sk_set_copy_thunks( \
+            OPENSSL_sk_set_cmp_thunks( \
+                OPENSSL_sk_deep_copy( \
+                    ossl_check_const_PKCS7_sk_type(sk), \
+                    ossl_check_PKCS7_copyfunc_type(copyfunc), \
+                    ossl_check_PKCS7_freefunc_type(freefunc)), \
+                sk_PKCS7_cmpfunc_thunk), \
+            sk_PKCS7_copyfunc_thunk), \
+        sk_PKCS7_freefunc_thunk))
 #define sk_PKCS7_set_cmp_func(sk, cmp) ((sk_PKCS7_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_PKCS7_sk_type(sk), ossl_check_PKCS7_compfunc_type(cmp)))
 
 /* clang-format on */
@@ -374,7 +490,9 @@ void PKCS7_RECIP_INFO_get0_alg(PKCS7_RECIP_INFO *ri, X509_ALGOR **penc);
 int PKCS7_add_recipient_info(PKCS7 *p7, PKCS7_RECIP_INFO *ri);
 int PKCS7_RECIP_INFO_set(PKCS7_RECIP_INFO *p7i, X509 *x509);
 int PKCS7_set_cipher(PKCS7 *p7, const EVP_CIPHER *cipher);
-int PKCS7_stream(unsigned char ***boundary, PKCS7 *p7);
+#if !defined(OPENSSL_NO_DEPRECATED_4_1)
+OSSL_DEPRECATEDIN_4_1 int PKCS7_stream(unsigned char ***boundary, PKCS7 *p7);
+#endif /* !defined(OPENSSL_NO_DEPRECATED_4_1) */
 
 PKCS7_ISSUER_AND_SERIAL *PKCS7_get_issuer_and_serial(PKCS7 *p7, int idx);
 ASN1_OCTET_STRING *PKCS7_get_octet_string(PKCS7 *p7);

package/dist/prebuilt/linuxmusl-x64-mt-release/include/openssl/pkcs7err.h

@@ -1,6 +1,6 @@
 /*
  * Generated by util/mkerr.pl DO NOT EDIT
- * Copyright 1995-2021 The OpenSSL Project Authors. All Rights Reserved.
+ * Copyright 1995-2026 The OpenSSL Project Authors. All Rights Reserved.
  *
  * Licensed under the Apache License 2.0 (the "License").  You may not use
  * this file except in compliance with the License.  You can obtain a copy

package/dist/prebuilt/linuxmusl-x64-mt-release/include/openssl/prov_ssl.h

@@ -1,5 +1,5 @@
 /*
- * Copyright 2021-2023 The OpenSSL Project Authors. All Rights Reserved.
+ * Copyright 2021-2026 The OpenSSL Project Authors. All Rights Reserved.
  *
  * Licensed under the Apache License 2.0 (the "License").  You may not use
  * this file except in compliance with the License.  You can obtain a copy
@@ -27,11 +27,17 @@ extern "C" {
 #define TLS1_3_VERSION 0x0304
 #define DTLS1_VERSION 0xFEFF
 #define DTLS1_2_VERSION 0xFEFD
+#define DTLS1_3_VERSION 0xFEFC
 #define DTLS1_BAD_VER 0x0100
 
+#define PROTO_VERSION_UNSET 0
+
 /* QUIC uses a 4 byte unsigned version number */
 #define OSSL_QUIC1_VERSION 0x0000001
 
+/* Maximum plaintext length: defined by SSL/TLS standards */
+#define SSL3_RT_MAX_PLAIN_LENGTH 16384
+
 #ifdef __cplusplus
 }
 #endif

package/dist/prebuilt/linuxmusl-x64-mt-release/include/openssl/proverr.h

@@ -32,7 +32,9 @@
 #define PROV_R_DERIVATION_FUNCTION_INIT_FAILED 205
 #define PROV_R_DIGEST_NOT_ALLOWED 174
 #define PROV_R_EMS_NOT_ENABLED 233
+#define PROV_R_ENTROPY_SOURCE_FAILED_APT_CONTINUOUS_TEST 268
 #define PROV_R_ENTROPY_SOURCE_FAILED_CONTINUOUS_TESTS 244
+#define PROV_R_ENTROPY_SOURCE_FAILED_RCT_CONTINUOUS_TEST 269
 #define PROV_R_ENTROPY_SOURCE_STRENGTH_TOO_WEAK 186
 #define PROV_R_ERROR_INSTANTIATING_DRBG 188
 #define PROV_R_ERROR_RETRIEVING_ENTROPY 189
@@ -49,6 +51,7 @@
 #define PROV_R_FIPS_MODULE_ENTERING_ERROR_STATE 224
 #define PROV_R_FIPS_MODULE_IMPORT_PCT_ERROR 253
 #define PROV_R_FIPS_MODULE_IN_ERROR_STATE 225
+#define PROV_R_FIPS_MODULE_MISSING_CHECKSUM 267
 #define PROV_R_GENERATE_ERROR 191
 #define PROV_R_ILLEGAL_OR_UNSUPPORTED_PADDING_MODE 165
 #define PROV_R_INDICATOR_INTEGRITY_FAILURE 210
@@ -80,11 +83,14 @@
 #define PROV_R_INVALID_MEMORY_SIZE 235
 #define PROV_R_INVALID_MGF1_MD 167
 #define PROV_R_INVALID_MODE 125
+#define PROV_R_INVALID_NONCE_LENGTH 264
 #define PROV_R_INVALID_OUTPUT_LENGTH 217
 #define PROV_R_INVALID_PADDING_MODE 168
+#define PROV_R_INVALID_PARAMETERS_FOR_DKM 261
 #define PROV_R_INVALID_PREHASHED_DIGEST_LENGTH 241
 #define PROV_R_INVALID_PUBINFO 198
 #define PROV_R_INVALID_SALT_LENGTH 112
+#define PROV_R_INVALID_SECRET_LENGTH 265
 #define PROV_R_INVALID_SEED_LENGTH 154
 #define PROV_R_INVALID_SIGNATURE_SIZE 179
 #define PROV_R_INVALID_STATE 212
@@ -94,6 +100,7 @@
 #define PROV_R_INVALID_UKM_LENGTH 200
 #define PROV_R_INVALID_X931_DIGEST 170
 #define PROV_R_IN_ERROR_STATE 192
+#define PROV_R_KEY_IMMUTABLE_ONCE_SET 266
 #define PROV_R_KEY_SETUP_FAILED 101
 #define PROV_R_KEY_SIZE_TOO_SMALL 171
 #define PROV_R_LENGTH_TOO_LARGE 202
@@ -102,10 +109,12 @@
 #define PROV_R_MISSING_CIPHER 155
 #define PROV_R_MISSING_CONFIG_DATA 213
 #define PROV_R_MISSING_CONSTANT 156
+#define PROV_R_MISSING_DKM 262
 #define PROV_R_MISSING_EID 255
 #define PROV_R_MISSING_KEY 128
 #define PROV_R_MISSING_MAC 150
 #define PROV_R_MISSING_MESSAGE_DIGEST 129
+#define PROV_R_MISSING_NONCE 263
 #define PROV_R_MISSING_OID 209
 #define PROV_R_MISSING_PASS 130
 #define PROV_R_MISSING_SALT 131

package/dist/prebuilt/linuxmusl-x64-mt-release/include/openssl/randerr.h

@@ -1,6 +1,6 @@
 /*
  * Generated by util/mkerr.pl DO NOT EDIT
- * Copyright 1995-2024 The OpenSSL Project Authors. All Rights Reserved.
+ * Copyright 1995-2026 The OpenSSL Project Authors. All Rights Reserved.
  *
  * Licensed under the Apache License 2.0 (the "License").  You may not use
  * this file except in compliance with the License.  You can obtain a copy

package/dist/prebuilt/linuxmusl-x64-mt-release/include/openssl/rsaerr.h

@@ -1,6 +1,6 @@
 /*
  * Generated by util/mkerr.pl DO NOT EDIT
- * Copyright 1995-2021 The OpenSSL Project Authors. All Rights Reserved.
+ * Copyright 1995-2026 The OpenSSL Project Authors. All Rights Reserved.
  *
  * Licensed under the Apache License 2.0 (the "License").  You may not use
  * this file except in compliance with the License.  You can obtain a copy

package/dist/prebuilt/linuxmusl-x64-mt-release/include/openssl/safestack.h

@@ -43,6 +43,11 @@ extern "C" {
         sk_##t1##_freefunc freefunc = (sk_##t1##_freefunc)freefunc_arg;                                                  \
         freefunc((t3 *)ptr);                                                                                             \
     }                                                                                                                    \
+    static ossl_inline void *sk_##t1##_copyfunc_thunk(OPENSSL_sk_copyfunc copyfunc_arg, const void *ptr)                 \
+    {                                                                                                                    \
+        sk_##t1##_copyfunc copyfunc = (sk_##t1##_copyfunc)copyfunc_arg;                                                  \
+        return (void *)copyfunc((const t3 *)ptr);                                                                        \
+    }                                                                                                                    \
     static ossl_inline int sk_##t1##_cmpfunc_thunk(int (*cmp)(const void *, const void *), const void *a, const void *b) \
     {                                                                                                                    \
         int (*realcmp)(const t3 *const *a, const t3 *const *b) = (int (*)(const t3 *const *a, const t3 *const *b))(cmp); \
@@ -86,6 +91,11 @@ extern "C" {
         sk_##t1##_freefunc freefunc = (sk_##t1##_freefunc)freefunc_arg;                                                    \
         freefunc((t3 *)ptr);                                                                                               \
     }                                                                                                                      \
+    static ossl_inline void *sk_##t1##_copyfunc_thunk(OPENSSL_sk_copyfunc copyfunc_arg, const void *ptr)                   \
+    {                                                                                                                      \
+        sk_##t1##_copyfunc copyfunc = (sk_##t1##_copyfunc)copyfunc_arg;                                                    \
+        return (void *)copyfunc((const t3 *)ptr);                                                                          \
+    }                                                                                                                      \
     static ossl_inline int sk_##t1##_cmpfunc_thunk(int (*cmp)(const void *, const void *), const void *a, const void *b)   \
     {                                                                                                                      \
         int (*realcmp)(const t3 *const *a, const t3 *const *b) = (int (*)(const t3 *const *a, const t3 *const *b))(cmp);   \
@@ -109,6 +119,7 @@ extern "C" {
                                                                                                                            \
         f_thunk = (OPENSSL_sk_freefunc_thunk)sk_##t1##_freefunc_thunk;                                                     \
         OPENSSL_sk_set_cmp_thunks(ret, sk_##t1##_cmpfunc_thunk);                                                           \
+        OPENSSL_sk_set_copy_thunks(ret, sk_##t1##_copyfunc_thunk);                                                         \
         return (STACK_OF(t1) *)OPENSSL_sk_set_thunks(ret, f_thunk);                                                        \
     }                                                                                                                      \
     static ossl_unused ossl_inline STACK_OF(t1) *sk_##t1##_new_null(void)                                                  \
@@ -117,7 +128,8 @@ extern "C" {
         OPENSSL_sk_freefunc_thunk f_thunk;                                                                                 \
                                                                                                                            \
         f_thunk = (OPENSSL_sk_freefunc_thunk)sk_##t1##_freefunc_thunk;                                                     \
-                                                                                                                           \
+        OPENSSL_sk_set_cmp_thunks(ret, sk_##t1##_cmpfunc_thunk);                                                           \
+        OPENSSL_sk_set_copy_thunks(ret, sk_##t1##_copyfunc_thunk);                                                         \
         return (STACK_OF(t1) *)OPENSSL_sk_set_thunks(ret, f_thunk);                                                        \
     }                                                                                                                      \
     static ossl_unused ossl_inline STACK_OF(t1) *sk_##t1##_new_reserve(sk_##t1##_compfunc compare, int n)                  \
@@ -127,6 +139,7 @@ extern "C" {
                                                                                                                            \
         f_thunk = (OPENSSL_sk_freefunc_thunk)sk_##t1##_freefunc_thunk;                                                     \
         OPENSSL_sk_set_cmp_thunks(ret, sk_##t1##_cmpfunc_thunk);                                                           \
+        OPENSSL_sk_set_copy_thunks(ret, sk_##t1##_copyfunc_thunk);                                                         \
         return (STACK_OF(t1) *)OPENSSL_sk_set_thunks(ret, f_thunk);                                                        \
     }                                                                                                                      \
     static ossl_unused ossl_inline int sk_##t1##_reserve(STACK_OF(t1) *sk, int n)                                          \
@@ -206,15 +219,27 @@ extern "C" {
     }                                                                                                                      \
     static ossl_unused ossl_inline STACK_OF(t1) *sk_##t1##_dup(const STACK_OF(t1) *sk)                                     \
     {                                                                                                                      \
-        return (STACK_OF(t1) *)OPENSSL_sk_dup((const OPENSSL_STACK *)sk);                                                  \
+        OPENSSL_STACK *ret = OPENSSL_sk_dup((const OPENSSL_STACK *)sk);                                                    \
+        OPENSSL_sk_freefunc_thunk f_thunk;                                                                                 \
+                                                                                                                           \
+        f_thunk = (OPENSSL_sk_freefunc_thunk)sk_##t1##_freefunc_thunk;                                                     \
+        OPENSSL_sk_set_cmp_thunks(ret, sk_##t1##_cmpfunc_thunk);                                                           \
+        OPENSSL_sk_set_copy_thunks(ret, sk_##t1##_copyfunc_thunk);                                                         \
+        return (STACK_OF(t1) *)OPENSSL_sk_set_thunks(ret, f_thunk);                                                        \
     }                                                                                                                      \
     static ossl_unused ossl_inline STACK_OF(t1) *sk_##t1##_deep_copy(const STACK_OF(t1) *sk,                               \
         sk_##t1##_copyfunc copyfunc,                                                                                       \
         sk_##t1##_freefunc freefunc)                                                                                       \
     {                                                                                                                      \
-        return (STACK_OF(t1) *)OPENSSL_sk_deep_copy((const OPENSSL_STACK *)sk,                                             \
+        OPENSSL_STACK *ret = OPENSSL_sk_deep_copy((const OPENSSL_STACK *)sk,                                               \
             (OPENSSL_sk_copyfunc)copyfunc,                                                                                 \
             (OPENSSL_sk_freefunc)freefunc);                                                                                \
+        OPENSSL_sk_freefunc_thunk f_thunk;                                                                                 \
+                                                                                                                           \
+        f_thunk = (OPENSSL_sk_freefunc_thunk)sk_##t1##_freefunc_thunk;                                                     \
+        OPENSSL_sk_set_cmp_thunks(ret, sk_##t1##_cmpfunc_thunk);                                                           \
+        OPENSSL_sk_set_copy_thunks(ret, sk_##t1##_copyfunc_thunk);                                                         \
+        return (STACK_OF(t1) *)OPENSSL_sk_set_thunks(ret, f_thunk);                                                        \
     }                                                                                                                      \
     static ossl_unused ossl_inline sk_##t1##_compfunc sk_##t1##_set_cmp_func(STACK_OF(t1) *sk, sk_##t1##_compfunc compare) \
     {                                                                                                                      \
@@ -255,9 +280,30 @@ typedef const char *OPENSSL_CSTRING;
 SKM_DEFINE_STACK_OF_INTERNAL(OPENSSL_STRING, char, char)
 #define sk_OPENSSL_STRING_num(sk) OPENSSL_sk_num(ossl_check_const_OPENSSL_STRING_sk_type(sk))
 #define sk_OPENSSL_STRING_value(sk, idx) ((char *)OPENSSL_sk_value(ossl_check_const_OPENSSL_STRING_sk_type(sk), (idx)))
-#define sk_OPENSSL_STRING_new(cmp) ((STACK_OF(OPENSSL_STRING) *)OPENSSL_sk_set_cmp_thunks(OPENSSL_sk_new(ossl_check_OPENSSL_STRING_compfunc_type(cmp)), sk_OPENSSL_STRING_cmpfunc_thunk))
-#define sk_OPENSSL_STRING_new_null() ((STACK_OF(OPENSSL_STRING) *)OPENSSL_sk_set_thunks(OPENSSL_sk_new_null(), sk_OPENSSL_STRING_freefunc_thunk))
-#define sk_OPENSSL_STRING_new_reserve(cmp, n) ((STACK_OF(OPENSSL_STRING) *)OPENSSL_sk_set_cmp_thunks(OPENSSL_sk_new_reserve(ossl_check_OPENSSL_STRING_compfunc_type(cmp), (n)), sk_OPENSSL_STRING_cmpfunc_thunk))
+#define sk_OPENSSL_STRING_new(cmp) \
+    ((STACK_OF(OPENSSL_STRING) *)OPENSSL_sk_set_thunks( \
+        OPENSSL_sk_set_copy_thunks( \
+            OPENSSL_sk_set_cmp_thunks( \
+                OPENSSL_sk_new(ossl_check_OPENSSL_STRING_compfunc_type(cmp)), \
+                sk_OPENSSL_STRING_cmpfunc_thunk), \
+            sk_OPENSSL_STRING_copyfunc_thunk), \
+        sk_OPENSSL_STRING_freefunc_thunk))
+#define sk_OPENSSL_STRING_new_null() \
+    ((STACK_OF(OPENSSL_STRING) *)OPENSSL_sk_set_thunks( \
+        OPENSSL_sk_set_copy_thunks( \
+            OPENSSL_sk_set_cmp_thunks( \
+                OPENSSL_sk_new_null(), \
+                sk_OPENSSL_STRING_cmpfunc_thunk), \
+            sk_OPENSSL_STRING_copyfunc_thunk), \
+        sk_OPENSSL_STRING_freefunc_thunk))
+#define sk_OPENSSL_STRING_new_reserve(cmp, n) \
+    ((STACK_OF(OPENSSL_STRING) *)OPENSSL_sk_set_thunks( \
+        OPENSSL_sk_set_copy_thunks( \
+            OPENSSL_sk_set_cmp_thunks( \
+                OPENSSL_sk_new_reserve(ossl_check_OPENSSL_STRING_compfunc_type(cmp), (n)), \
+                sk_OPENSSL_STRING_cmpfunc_thunk), \
+            sk_OPENSSL_STRING_copyfunc_thunk), \
+        sk_OPENSSL_STRING_freefunc_thunk))
 #define sk_OPENSSL_STRING_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_OPENSSL_STRING_sk_type(sk), (n))
 #define sk_OPENSSL_STRING_free(sk) OPENSSL_sk_free(ossl_check_OPENSSL_STRING_sk_type(sk))
 #define sk_OPENSSL_STRING_zero(sk) OPENSSL_sk_zero(ossl_check_OPENSSL_STRING_sk_type(sk))
@@ -275,15 +321,53 @@ SKM_DEFINE_STACK_OF_INTERNAL(OPENSSL_STRING, char, char)
 #define sk_OPENSSL_STRING_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_OPENSSL_STRING_sk_type(sk), ossl_check_OPENSSL_STRING_type(ptr), pnum)
 #define sk_OPENSSL_STRING_sort(sk) OPENSSL_sk_sort(ossl_check_OPENSSL_STRING_sk_type(sk))
 #define sk_OPENSSL_STRING_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_OPENSSL_STRING_sk_type(sk))
-#define sk_OPENSSL_STRING_dup(sk) ((STACK_OF(OPENSSL_STRING) *)OPENSSL_sk_dup(ossl_check_const_OPENSSL_STRING_sk_type(sk)))
-#define sk_OPENSSL_STRING_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(OPENSSL_STRING) *)OPENSSL_sk_deep_copy(ossl_check_const_OPENSSL_STRING_sk_type(sk), ossl_check_OPENSSL_STRING_copyfunc_type(copyfunc), ossl_check_OPENSSL_STRING_freefunc_type(freefunc)))
+#define sk_OPENSSL_STRING_dup(sk) \
+    ((STACK_OF(OPENSSL_STRING) *)OPENSSL_sk_set_thunks( \
+        OPENSSL_sk_set_copy_thunks( \
+            OPENSSL_sk_set_cmp_thunks( \
+                OPENSSL_sk_dup(ossl_check_const_OPENSSL_STRING_sk_type(sk)), \
+                sk_OPENSSL_STRING_cmpfunc_thunk), \
+            sk_OPENSSL_STRING_copyfunc_thunk), \
+        sk_OPENSSL_STRING_freefunc_thunk))
+#define sk_OPENSSL_STRING_deep_copy(sk, copyfunc, freefunc) \
+    ((STACK_OF(OPENSSL_STRING) *)OPENSSL_sk_set_thunks( \
+        OPENSSL_sk_set_copy_thunks( \
+            OPENSSL_sk_set_cmp_thunks( \
+                OPENSSL_sk_deep_copy( \
+                    ossl_check_const_OPENSSL_STRING_sk_type(sk), \
+                    ossl_check_OPENSSL_STRING_copyfunc_type(copyfunc), \
+                    ossl_check_OPENSSL_STRING_freefunc_type(freefunc)), \
+                sk_OPENSSL_STRING_cmpfunc_thunk), \
+            sk_OPENSSL_STRING_copyfunc_thunk), \
+        sk_OPENSSL_STRING_freefunc_thunk))
 #define sk_OPENSSL_STRING_set_cmp_func(sk, cmp) ((sk_OPENSSL_STRING_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_OPENSSL_STRING_sk_type(sk), ossl_check_OPENSSL_STRING_compfunc_type(cmp)))
 SKM_DEFINE_STACK_OF_INTERNAL(OPENSSL_CSTRING, const char, char)
 #define sk_OPENSSL_CSTRING_num(sk) OPENSSL_sk_num(ossl_check_const_OPENSSL_CSTRING_sk_type(sk))
 #define sk_OPENSSL_CSTRING_value(sk, idx) ((const char *)OPENSSL_sk_value(ossl_check_const_OPENSSL_CSTRING_sk_type(sk), (idx)))
-#define sk_OPENSSL_CSTRING_new(cmp) ((STACK_OF(OPENSSL_CSTRING) *)OPENSSL_sk_set_cmp_thunks(OPENSSL_sk_new(ossl_check_OPENSSL_CSTRING_compfunc_type(cmp)), sk_OPENSSL_CSTRING_cmpfunc_thunk))
-#define sk_OPENSSL_CSTRING_new_null() ((STACK_OF(OPENSSL_CSTRING) *)OPENSSL_sk_set_thunks(OPENSSL_sk_new_null(), sk_OPENSSL_CSTRING_freefunc_thunk))
-#define sk_OPENSSL_CSTRING_new_reserve(cmp, n) ((STACK_OF(OPENSSL_CSTRING) *)OPENSSL_sk_set_cmp_thunks(OPENSSL_sk_new_reserve(ossl_check_OPENSSL_CSTRING_compfunc_type(cmp), (n)), sk_OPENSSL_CSTRING_cmpfunc_thunk))
+#define sk_OPENSSL_CSTRING_new(cmp) \
+    ((STACK_OF(OPENSSL_CSTRING) *)OPENSSL_sk_set_thunks( \
+        OPENSSL_sk_set_copy_thunks( \
+            OPENSSL_sk_set_cmp_thunks( \
+                OPENSSL_sk_new(ossl_check_OPENSSL_CSTRING_compfunc_type(cmp)), \
+                sk_OPENSSL_CSTRING_cmpfunc_thunk), \
+            sk_OPENSSL_CSTRING_copyfunc_thunk), \
+        sk_OPENSSL_CSTRING_freefunc_thunk))
+#define sk_OPENSSL_CSTRING_new_null() \
+    ((STACK_OF(OPENSSL_CSTRING) *)OPENSSL_sk_set_thunks( \
+        OPENSSL_sk_set_copy_thunks( \
+            OPENSSL_sk_set_cmp_thunks( \
+                OPENSSL_sk_new_null(), \
+                sk_OPENSSL_CSTRING_cmpfunc_thunk), \
+            sk_OPENSSL_CSTRING_copyfunc_thunk), \
+        sk_OPENSSL_CSTRING_freefunc_thunk))
+#define sk_OPENSSL_CSTRING_new_reserve(cmp, n) \
+    ((STACK_OF(OPENSSL_CSTRING) *)OPENSSL_sk_set_thunks( \
+        OPENSSL_sk_set_copy_thunks( \
+            OPENSSL_sk_set_cmp_thunks( \
+                OPENSSL_sk_new_reserve(ossl_check_OPENSSL_CSTRING_compfunc_type(cmp), (n)), \
+                sk_OPENSSL_CSTRING_cmpfunc_thunk), \
+            sk_OPENSSL_CSTRING_copyfunc_thunk), \
+        sk_OPENSSL_CSTRING_freefunc_thunk))
 #define sk_OPENSSL_CSTRING_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_OPENSSL_CSTRING_sk_type(sk), (n))
 #define sk_OPENSSL_CSTRING_free(sk) OPENSSL_sk_free(ossl_check_OPENSSL_CSTRING_sk_type(sk))
 #define sk_OPENSSL_CSTRING_zero(sk) OPENSSL_sk_zero(ossl_check_OPENSSL_CSTRING_sk_type(sk))
@@ -301,8 +385,25 @@ SKM_DEFINE_STACK_OF_INTERNAL(OPENSSL_CSTRING, const char, char)
 #define sk_OPENSSL_CSTRING_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_OPENSSL_CSTRING_sk_type(sk), ossl_check_OPENSSL_CSTRING_type(ptr), pnum)
 #define sk_OPENSSL_CSTRING_sort(sk) OPENSSL_sk_sort(ossl_check_OPENSSL_CSTRING_sk_type(sk))
 #define sk_OPENSSL_CSTRING_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_OPENSSL_CSTRING_sk_type(sk))
-#define sk_OPENSSL_CSTRING_dup(sk) ((STACK_OF(OPENSSL_CSTRING) *)OPENSSL_sk_dup(ossl_check_const_OPENSSL_CSTRING_sk_type(sk)))
-#define sk_OPENSSL_CSTRING_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(OPENSSL_CSTRING) *)OPENSSL_sk_deep_copy(ossl_check_const_OPENSSL_CSTRING_sk_type(sk), ossl_check_OPENSSL_CSTRING_copyfunc_type(copyfunc), ossl_check_OPENSSL_CSTRING_freefunc_type(freefunc)))
+#define sk_OPENSSL_CSTRING_dup(sk) \
+    ((STACK_OF(OPENSSL_CSTRING) *)OPENSSL_sk_set_thunks( \
+        OPENSSL_sk_set_copy_thunks( \
+            OPENSSL_sk_set_cmp_thunks( \
+                OPENSSL_sk_dup(ossl_check_const_OPENSSL_CSTRING_sk_type(sk)), \
+                sk_OPENSSL_CSTRING_cmpfunc_thunk), \
+            sk_OPENSSL_CSTRING_copyfunc_thunk), \
+        sk_OPENSSL_CSTRING_freefunc_thunk))
+#define sk_OPENSSL_CSTRING_deep_copy(sk, copyfunc, freefunc) \
+    ((STACK_OF(OPENSSL_CSTRING) *)OPENSSL_sk_set_thunks( \
+        OPENSSL_sk_set_copy_thunks( \
+            OPENSSL_sk_set_cmp_thunks( \
+                OPENSSL_sk_deep_copy( \
+                    ossl_check_const_OPENSSL_CSTRING_sk_type(sk), \
+                    ossl_check_OPENSSL_CSTRING_copyfunc_type(copyfunc), \
+                    ossl_check_OPENSSL_CSTRING_freefunc_type(freefunc)), \
+                sk_OPENSSL_CSTRING_cmpfunc_thunk), \
+            sk_OPENSSL_CSTRING_copyfunc_thunk), \
+        sk_OPENSSL_CSTRING_freefunc_thunk))
 #define sk_OPENSSL_CSTRING_set_cmp_func(sk, cmp) ((sk_OPENSSL_CSTRING_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_OPENSSL_CSTRING_sk_type(sk), ossl_check_OPENSSL_CSTRING_compfunc_type(cmp)))
 
 /* clang-format on */
@@ -317,9 +418,30 @@ typedef void *OPENSSL_BLOCK;
 SKM_DEFINE_STACK_OF_INTERNAL(OPENSSL_BLOCK, void, void)
 #define sk_OPENSSL_BLOCK_num(sk) OPENSSL_sk_num(ossl_check_const_OPENSSL_BLOCK_sk_type(sk))
 #define sk_OPENSSL_BLOCK_value(sk, idx) ((void *)OPENSSL_sk_value(ossl_check_const_OPENSSL_BLOCK_sk_type(sk), (idx)))
-#define sk_OPENSSL_BLOCK_new(cmp) ((STACK_OF(OPENSSL_BLOCK) *)OPENSSL_sk_set_cmp_thunks(OPENSSL_sk_new(ossl_check_OPENSSL_BLOCK_compfunc_type(cmp)), sk_OPENSSL_BLOCK_cmpfunc_thunk))
-#define sk_OPENSSL_BLOCK_new_null() ((STACK_OF(OPENSSL_BLOCK) *)OPENSSL_sk_set_thunks(OPENSSL_sk_new_null(), sk_OPENSSL_BLOCK_freefunc_thunk))
-#define sk_OPENSSL_BLOCK_new_reserve(cmp, n) ((STACK_OF(OPENSSL_BLOCK) *)OPENSSL_sk_set_cmp_thunks(OPENSSL_sk_new_reserve(ossl_check_OPENSSL_BLOCK_compfunc_type(cmp), (n)), sk_OPENSSL_BLOCK_cmpfunc_thunk))
+#define sk_OPENSSL_BLOCK_new(cmp) \
+    ((STACK_OF(OPENSSL_BLOCK) *)OPENSSL_sk_set_thunks( \
+        OPENSSL_sk_set_copy_thunks( \
+            OPENSSL_sk_set_cmp_thunks( \
+                OPENSSL_sk_new(ossl_check_OPENSSL_BLOCK_compfunc_type(cmp)), \
+                sk_OPENSSL_BLOCK_cmpfunc_thunk), \
+            sk_OPENSSL_BLOCK_copyfunc_thunk), \
+        sk_OPENSSL_BLOCK_freefunc_thunk))
+#define sk_OPENSSL_BLOCK_new_null() \
+    ((STACK_OF(OPENSSL_BLOCK) *)OPENSSL_sk_set_thunks( \
+        OPENSSL_sk_set_copy_thunks( \
+            OPENSSL_sk_set_cmp_thunks( \
+                OPENSSL_sk_new_null(), \
+                sk_OPENSSL_BLOCK_cmpfunc_thunk), \
+            sk_OPENSSL_BLOCK_copyfunc_thunk), \
+        sk_OPENSSL_BLOCK_freefunc_thunk))
+#define sk_OPENSSL_BLOCK_new_reserve(cmp, n) \
+    ((STACK_OF(OPENSSL_BLOCK) *)OPENSSL_sk_set_thunks( \
+        OPENSSL_sk_set_copy_thunks( \
+            OPENSSL_sk_set_cmp_thunks( \
+                OPENSSL_sk_new_reserve(ossl_check_OPENSSL_BLOCK_compfunc_type(cmp), (n)), \
+                sk_OPENSSL_BLOCK_cmpfunc_thunk), \
+            sk_OPENSSL_BLOCK_copyfunc_thunk), \
+        sk_OPENSSL_BLOCK_freefunc_thunk))
 #define sk_OPENSSL_BLOCK_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_OPENSSL_BLOCK_sk_type(sk), (n))
 #define sk_OPENSSL_BLOCK_free(sk) OPENSSL_sk_free(ossl_check_OPENSSL_BLOCK_sk_type(sk))
 #define sk_OPENSSL_BLOCK_zero(sk) OPENSSL_sk_zero(ossl_check_OPENSSL_BLOCK_sk_type(sk))
@@ -337,8 +459,25 @@ SKM_DEFINE_STACK_OF_INTERNAL(OPENSSL_BLOCK, void, void)
 #define sk_OPENSSL_BLOCK_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_OPENSSL_BLOCK_sk_type(sk), ossl_check_OPENSSL_BLOCK_type(ptr), pnum)
 #define sk_OPENSSL_BLOCK_sort(sk) OPENSSL_sk_sort(ossl_check_OPENSSL_BLOCK_sk_type(sk))
 #define sk_OPENSSL_BLOCK_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_OPENSSL_BLOCK_sk_type(sk))
-#define sk_OPENSSL_BLOCK_dup(sk) ((STACK_OF(OPENSSL_BLOCK) *)OPENSSL_sk_dup(ossl_check_const_OPENSSL_BLOCK_sk_type(sk)))
-#define sk_OPENSSL_BLOCK_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(OPENSSL_BLOCK) *)OPENSSL_sk_deep_copy(ossl_check_const_OPENSSL_BLOCK_sk_type(sk), ossl_check_OPENSSL_BLOCK_copyfunc_type(copyfunc), ossl_check_OPENSSL_BLOCK_freefunc_type(freefunc)))
+#define sk_OPENSSL_BLOCK_dup(sk) \
+    ((STACK_OF(OPENSSL_BLOCK) *)OPENSSL_sk_set_thunks( \
+        OPENSSL_sk_set_copy_thunks( \
+            OPENSSL_sk_set_cmp_thunks( \
+                OPENSSL_sk_dup(ossl_check_const_OPENSSL_BLOCK_sk_type(sk)), \
+                sk_OPENSSL_BLOCK_cmpfunc_thunk), \
+            sk_OPENSSL_BLOCK_copyfunc_thunk), \
+        sk_OPENSSL_BLOCK_freefunc_thunk))
+#define sk_OPENSSL_BLOCK_deep_copy(sk, copyfunc, freefunc) \
+    ((STACK_OF(OPENSSL_BLOCK) *)OPENSSL_sk_set_thunks( \
+        OPENSSL_sk_set_copy_thunks( \
+            OPENSSL_sk_set_cmp_thunks( \
+                OPENSSL_sk_deep_copy( \
+                    ossl_check_const_OPENSSL_BLOCK_sk_type(sk), \
+                    ossl_check_OPENSSL_BLOCK_copyfunc_type(copyfunc), \
+                    ossl_check_OPENSSL_BLOCK_freefunc_type(freefunc)), \
+                sk_OPENSSL_BLOCK_cmpfunc_thunk), \
+            sk_OPENSSL_BLOCK_copyfunc_thunk), \
+        sk_OPENSSL_BLOCK_freefunc_thunk))
 #define sk_OPENSSL_BLOCK_set_cmp_func(sk, cmp) ((sk_OPENSSL_BLOCK_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_OPENSSL_BLOCK_sk_type(sk), ossl_check_OPENSSL_BLOCK_compfunc_type(cmp)))
 
 /* clang-format on */

package/dist/prebuilt/linuxmusl-x64-mt-release/include/openssl/self_test.h

@@ -80,6 +80,11 @@ extern "C" {
 #define OSSL_SELF_TEST_DESC_KA_DH "DH"
 #define OSSL_SELF_TEST_DESC_KA_ECDH "ECDH"
 #define OSSL_SELF_TEST_DESC_KDF_HKDF "HKDF"
+#define OSSL_SELF_TEST_DESC_KDF_IKEV2KDF_GEN "IKEV2KDF_GEN"
+#define OSSL_SELF_TEST_DESC_KDF_IKEV2KDF_DKM1 "IKEV2KDF_DKM"
+#define OSSL_SELF_TEST_DESC_KDF_IKEV2KDF_DKM2 "IKEV2KDF_DKM(Child_SA)"
+#define OSSL_SELF_TEST_DESC_KDF_IKEV2KDF_DKM3 "IKEV2KDF_DKM(Child_DH)"
+#define OSSL_SELF_TEST_DESC_KDF_IKEV2KDF_REKEY "IKEV2KDF_REKEY"
 #define OSSL_SELF_TEST_DESC_KDF_SSKDF "SSKDF"
 #define OSSL_SELF_TEST_DESC_KDF_X963KDF "X963KDF"
 #define OSSL_SELF_TEST_DESC_KDF_X942KDF "X942KDF"