Hide public symbols in libcrypto/x509 .c files

ok tb@
author: beck <> 2022-11-14 17:48:50 +0000
committer: beck <> 2022-11-14 17:48:50 +0000
commit: 109899f1b36632f5f1c469c4f562df69585eb21e (patch)
tree: c42f727f8848b4a56e738422f26e8b44150174e4 /src
parent: fd2db7678bc81cd8abe106c7bd1c724c8b01888d (diff)
download: openbsd-109899f1b36632f5f1c469c4f562df69585eb21e.tar.gz
openbsd-109899f1b36632f5f1c469c4f562df69585eb21e.tar.bz2
openbsd-109899f1b36632f5f1c469c4f562df69585eb21e.zip
55 files changed, 2073 insertions, 52 deletions
diff --git a/src/lib/libcrypto/Symbols.namespace b/src/lib/libcrypto/Symbols.namespace
index 270be2262a..b4be562f6a 100644
--- a/src/lib/libcrypto/Symbols.namespace
+++ b/src/lib/libcrypto/Symbols.namespace
@@ -257,3 +257,652 @@ _libre_UI_set_result
 _libre_UI_UTIL_read_pw_string
 _libre_UI_UTIL_read_pw
 _libre_ERR_load_UI_strings
+_libre_X509_CRL_up_ref
+_libre_i2d_re_X509_CRL_tbs
+_libre_X509_get_X509_PUBKEY
+_libre_X509_verify_cert_error_string
+_libre_X509_verify
+_libre_X509_REQ_verify
+_libre_NETSCAPE_SPKI_verify
+_libre_NETSCAPE_SPKI_b64_decode
+_libre_NETSCAPE_SPKI_b64_encode
+_libre_NETSCAPE_SPKI_get_pubkey
+_libre_NETSCAPE_SPKI_set_pubkey
+_libre_X509_sign
+_libre_X509_sign_ctx
+_libre_X509_REQ_sign
+_libre_X509_REQ_sign_ctx
+_libre_X509_CRL_sign
+_libre_X509_CRL_sign_ctx
+_libre_NETSCAPE_SPKI_sign
+_libre_X509_pubkey_digest
+_libre_X509_digest
+_libre_X509_CRL_digest
+_libre_X509_REQ_digest
+_libre_X509_NAME_digest
+_libre_d2i_X509_fp
+_libre_i2d_X509_fp
+_libre_d2i_X509_CRL_fp
+_libre_i2d_X509_CRL_fp
+_libre_d2i_X509_REQ_fp
+_libre_i2d_X509_REQ_fp
+_libre_d2i_RSAPrivateKey_fp
+_libre_i2d_RSAPrivateKey_fp
+_libre_d2i_RSAPublicKey_fp
+_libre_i2d_RSAPublicKey_fp
+_libre_d2i_DSAPrivateKey_fp
+_libre_i2d_DSAPrivateKey_fp
+_libre_d2i_ECPrivateKey_fp
+_libre_i2d_ECPrivateKey_fp
+_libre_d2i_PKCS8_fp
+_libre_i2d_PKCS8_fp
+_libre_d2i_PKCS8_PRIV_KEY_INFO_fp
+_libre_i2d_PKCS8_PRIV_KEY_INFO_fp
+_libre_i2d_PKCS8PrivateKeyInfo_fp
+_libre_i2d_PrivateKey_fp
+_libre_d2i_PrivateKey_fp
+_libre_d2i_X509_bio
+_libre_i2d_X509_bio
+_libre_d2i_X509_CRL_bio
+_libre_i2d_X509_CRL_bio
+_libre_d2i_X509_REQ_bio
+_libre_i2d_X509_REQ_bio
+_libre_d2i_RSAPrivateKey_bio
+_libre_i2d_RSAPrivateKey_bio
+_libre_d2i_RSAPublicKey_bio
+_libre_i2d_RSAPublicKey_bio
+_libre_d2i_DSAPrivateKey_bio
+_libre_i2d_DSAPrivateKey_bio
+_libre_d2i_ECPrivateKey_bio
+_libre_i2d_ECPrivateKey_bio
+_libre_d2i_PKCS8_bio
+_libre_i2d_PKCS8_bio
+_libre_d2i_PKCS8_PRIV_KEY_INFO_bio
+_libre_i2d_PKCS8_PRIV_KEY_INFO_bio
+_libre_i2d_PKCS8PrivateKeyInfo_bio
+_libre_i2d_PrivateKey_bio
+_libre_d2i_PrivateKey_bio
+_libre_X509_cmp_time
+_libre_X509_cmp_current_time
+_libre_X509_time_adj
+_libre_X509_time_adj_ex
+_libre_X509_gmtime_adj
+_libre_X509_get_default_cert_area
+_libre_X509_get_default_cert_dir
+_libre_X509_get_default_cert_file
+_libre_X509_get_default_cert_dir_env
+_libre_X509_get_default_cert_file_env
+_libre_X509_get_default_private_dir
+_libre_X509_to_X509_REQ
+_libre_X509_REQ_to_X509
+_libre_X509_get_pubkey_parameters
+_libre_X509_TRUST_set_default
+_libre_X509_TRUST_set
+_libre_X509_NAME_oneline
+_libre_X509_get0_extensions
+_libre_X509_get0_tbs_sigalg
+_libre_X509_set_version
+_libre_X509_get_version
+_libre_X509_set_serialNumber
+_libre_X509_get_serialNumber
+_libre_X509_get0_serialNumber
+_libre_X509_set_issuer_name
+_libre_X509_get_issuer_name
+_libre_X509_set_subject_name
+_libre_X509_get_subject_name
+_libre_X509_set_notBefore
+_libre_X509_set1_notBefore
+_libre_X509_set_notAfter
+_libre_X509_set1_notAfter
+_libre_X509_get0_notBefore
+_libre_X509_getm_notBefore
+_libre_X509_get0_notAfter
+_libre_X509_getm_notAfter
+_libre_X509_set_pubkey
+_libre_X509_get_pubkey
+_libre_X509_get0_pubkey
+_libre_X509_get0_pubkey_bitstr
+_libre_X509_certificate_type
+_libre_X509_get_signature_type
+_libre_X509_REQ_set_version
+_libre_X509_REQ_get_version
+_libre_X509_REQ_set_subject_name
+_libre_X509_REQ_get_subject_name
+_libre_X509_REQ_set_pubkey
+_libre_X509_REQ_get_pubkey
+_libre_i2d_re_X509_REQ_tbs
+_libre_X509_REQ_get0_pubkey
+_libre_X509_REQ_extension_nid
+_libre_X509_REQ_get_extension_nids
+_libre_X509_REQ_set_extension_nids
+_libre_X509_REQ_get_extensions
+_libre_X509_REQ_add_extensions_nid
+_libre_X509_REQ_add_extensions
+_libre_X509_REQ_get_attr_count
+_libre_X509_REQ_get_attr_by_NID
+_libre_X509_REQ_get_attr_by_OBJ
+_libre_X509_REQ_get_attr
+_libre_X509_REQ_delete_attr
+_libre_X509_REQ_add1_attr
+_libre_X509_REQ_add1_attr_by_OBJ
+_libre_X509_REQ_add1_attr_by_NID
+_libre_X509_REQ_add1_attr_by_txt
+_libre_X509_CRL_set_version
+_libre_X509_CRL_set_issuer_name
+_libre_X509_CRL_set_lastUpdate
+_libre_X509_CRL_set1_lastUpdate
+_libre_X509_CRL_set_nextUpdate
+_libre_X509_CRL_set1_nextUpdate
+_libre_X509_CRL_sort
+_libre_X509_REVOKED_get0_extensions
+_libre_X509_REVOKED_get0_revocationDate
+_libre_X509_REVOKED_get0_serialNumber
+_libre_X509_REVOKED_set_revocationDate
+_libre_X509_REVOKED_set_serialNumber
+_libre_X509_REQ_check_private_key
+_libre_X509_check_private_key
+_libre_X509_issuer_and_serial_cmp
+_libre_X509_issuer_and_serial_hash
+_libre_X509_issuer_name_cmp
+_libre_X509_issuer_name_hash
+_libre_X509_subject_name_cmp
+_libre_X509_subject_name_hash
+_libre_X509_issuer_name_hash_old
+_libre_X509_subject_name_hash_old
+_libre_X509_cmp
+_libre_X509_NAME_cmp
+_libre_X509_NAME_hash
+_libre_X509_NAME_hash_old
+_libre_X509_CRL_cmp
+_libre_X509_CRL_match
+_libre_X509_NAME_entry_count
+_libre_X509_NAME_get_text_by_NID
+_libre_X509_NAME_get_text_by_OBJ
+_libre_X509_NAME_get_index_by_NID
+_libre_X509_NAME_get_index_by_OBJ
+_libre_X509_NAME_get_entry
+_libre_X509_NAME_delete_entry
+_libre_X509_NAME_add_entry
+_libre_X509_NAME_add_entry_by_OBJ
+_libre_X509_NAME_add_entry_by_NID
+_libre_X509_NAME_ENTRY_create_by_txt
+_libre_X509_NAME_ENTRY_create_by_NID
+_libre_X509_NAME_add_entry_by_txt
+_libre_X509_NAME_ENTRY_create_by_OBJ
+_libre_X509_NAME_ENTRY_set_object
+_libre_X509_NAME_ENTRY_set_data
+_libre_X509_NAME_ENTRY_get_object
+_libre_X509_NAME_ENTRY_get_data
+_libre_X509_NAME_ENTRY_set
+_libre_X509v3_get_ext_count
+_libre_X509v3_get_ext_by_NID
+_libre_X509v3_get_ext_by_OBJ
+_libre_X509v3_get_ext_by_critical
+_libre_X509v3_get_ext
+_libre_X509v3_delete_ext
+_libre_X509v3_add_ext
+_libre_X509_get_ext_count
+_libre_X509_get_ext_by_NID
+_libre_X509_get_ext_by_OBJ
+_libre_X509_get_ext_by_critical
+_libre_X509_get_ext
+_libre_X509_delete_ext
+_libre_X509_add_ext
+_libre_X509_get_ext_d2i
+_libre_X509_add1_ext_i2d
+_libre_X509_CRL_get_ext_count
+_libre_X509_CRL_get_ext_by_NID
+_libre_X509_CRL_get_ext_by_OBJ
+_libre_X509_CRL_get_ext_by_critical
+_libre_X509_CRL_get_ext
+_libre_X509_CRL_delete_ext
+_libre_X509_CRL_add_ext
+_libre_X509_CRL_get_ext_d2i
+_libre_X509_CRL_add1_ext_i2d
+_libre_X509_REVOKED_get_ext_count
+_libre_X509_REVOKED_get_ext_by_NID
+_libre_X509_REVOKED_get_ext_by_OBJ
+_libre_X509_REVOKED_get_ext_by_critical
+_libre_X509_REVOKED_get_ext
+_libre_X509_REVOKED_delete_ext
+_libre_X509_REVOKED_add_ext
+_libre_X509_REVOKED_get_ext_d2i
+_libre_X509_REVOKED_add1_ext_i2d
+_libre_X509_EXTENSION_create_by_NID
+_libre_X509_EXTENSION_create_by_OBJ
+_libre_X509_EXTENSION_set_object
+_libre_X509_EXTENSION_set_critical
+_libre_X509_EXTENSION_set_data
+_libre_X509_EXTENSION_get_object
+_libre_X509_EXTENSION_get_data
+_libre_X509_EXTENSION_get_critical
+_libre_X509at_get_attr_count
+_libre_X509at_get_attr_by_NID
+_libre_X509at_get_attr_by_OBJ
+_libre_X509at_get_attr
+_libre_X509at_delete_attr
+_libre_X509at_add1_attr
+_libre_X509at_add1_attr_by_OBJ
+_libre_X509at_add1_attr_by_NID
+_libre_X509at_add1_attr_by_txt
+_libre_X509at_get0_data_by_OBJ
+_libre_X509_ATTRIBUTE_create_by_NID
+_libre_X509_ATTRIBUTE_create_by_OBJ
+_libre_X509_ATTRIBUTE_create_by_txt
+_libre_X509_ATTRIBUTE_set1_object
+_libre_X509_ATTRIBUTE_set1_data
+_libre_X509_ATTRIBUTE_get0_data
+_libre_X509_ATTRIBUTE_count
+_libre_X509_ATTRIBUTE_get0_object
+_libre_X509_ATTRIBUTE_get0_type
+_libre_X509_verify_cert
+_libre_X509_find_by_issuer_and_serial
+_libre_X509_find_by_subject
+_libre_X509_check_trust
+_libre_X509_TRUST_get_count
+_libre_X509_TRUST_get0
+_libre_X509_TRUST_get_by_id
+_libre_X509_TRUST_add
+_libre_X509_TRUST_cleanup
+_libre_X509_TRUST_get_flags
+_libre_X509_TRUST_get0_name
+_libre_X509_TRUST_get_trust
+_libre_X509_up_ref
+_libre_X509_chain_up_ref
+_libre_ERR_load_X509_strings
+_libre_X509_STORE_set_depth
+_libre_X509_STORE_CTX_set_depth
+_libre_X509_OBJECT_new
+_libre_X509_OBJECT_free
+_libre_X509_OBJECT_idx_by_subject
+_libre_X509_OBJECT_retrieve_by_subject
+_libre_X509_OBJECT_retrieve_match
+_libre_X509_OBJECT_up_ref_count
+_libre_X509_OBJECT_get_type
+_libre_X509_OBJECT_get0_X509
+_libre_X509_OBJECT_get0_X509_CRL
+_libre_X509_STORE_new
+_libre_X509_STORE_free
+_libre_X509_STORE_up_ref
+_libre_X509_STORE_get1_certs
+_libre_X509_STORE_get1_crls
+_libre_X509_STORE_get0_objects
+_libre_X509_STORE_get_ex_data
+_libre_X509_STORE_set_ex_data
+_libre_X509_STORE_set_flags
+_libre_X509_STORE_set_purpose
+_libre_X509_STORE_set_trust
+_libre_X509_STORE_set1_param
+_libre_X509_STORE_get0_param
+_libre_X509_STORE_get_verify_cb
+_libre_X509_STORE_set_verify_cb
+_libre_X509_STORE_CTX_new
+_libre_X509_STORE_CTX_get1_issuer
+_libre_X509_STORE_CTX_free
+_libre_X509_STORE_CTX_init
+_libre_X509_STORE_CTX_get0_cert
+_libre_X509_STORE_CTX_get0_chain
+_libre_X509_STORE_CTX_get0_store
+_libre_X509_STORE_CTX_get0_untrusted
+_libre_X509_STORE_CTX_set0_untrusted
+_libre_X509_STORE_CTX_trusted_stack
+_libre_X509_STORE_CTX_set0_trusted_stack
+_libre_X509_STORE_CTX_cleanup
+_libre_X509_STORE_add_lookup
+_libre_X509_LOOKUP_hash_dir
+_libre_X509_LOOKUP_file
+_libre_X509_LOOKUP_mem
+_libre_X509_STORE_add_cert
+_libre_X509_STORE_add_crl
+_libre_X509_STORE_CTX_get_by_subject
+_libre_X509_STORE_CTX_get_obj_by_subject
+_libre_X509_LOOKUP_ctrl
+_libre_X509_load_cert_file
+_libre_X509_load_crl_file
+_libre_X509_load_cert_crl_file
+_libre_X509_LOOKUP_new
+_libre_X509_LOOKUP_free
+_libre_X509_LOOKUP_init
+_libre_X509_LOOKUP_by_subject
+_libre_X509_LOOKUP_by_issuer_serial
+_libre_X509_LOOKUP_by_fingerprint
+_libre_X509_LOOKUP_by_alias
+_libre_X509_LOOKUP_shutdown
+_libre_X509_STORE_load_locations
+_libre_X509_STORE_load_mem
+_libre_X509_STORE_set_default_paths
+_libre_X509_STORE_CTX_get_ex_new_index
+_libre_X509_STORE_CTX_set_ex_data
+_libre_X509_STORE_CTX_get_ex_data
+_libre_X509_STORE_CTX_get_error
+_libre_X509_STORE_CTX_set_error
+_libre_X509_STORE_CTX_get_error_depth
+_libre_X509_STORE_CTX_set_error_depth
+_libre_X509_STORE_CTX_get_current_cert
+_libre_X509_STORE_CTX_set_current_cert
+_libre_X509_STORE_CTX_get0_current_issuer
+_libre_X509_STORE_CTX_get0_current_crl
+_libre_X509_STORE_CTX_get0_parent_ctx
+_libre_X509_STORE_CTX_get_chain
+_libre_X509_STORE_CTX_get1_chain
+_libre_X509_STORE_CTX_set_cert
+_libre_X509_STORE_CTX_set_chain
+_libre_X509_STORE_CTX_set0_crls
+_libre_X509_STORE_CTX_set_purpose
+_libre_X509_STORE_CTX_set_trust
+_libre_X509_STORE_CTX_purpose_inherit
+_libre_X509_STORE_CTX_set_flags
+_libre_X509_STORE_CTX_set_time
+_libre_X509_STORE_CTX_set0_verified_chain
+_libre_X509_STORE_CTX_get_verify
+_libre_X509_STORE_CTX_set_verify
+_libre_X509_STORE_CTX_get_verify_cb
+_libre_X509_STORE_CTX_set_verify_cb
+_libre_X509_STORE_set_verify
+_libre_X509_STORE_get_verify
+_libre_X509_STORE_CTX_get0_policy_tree
+_libre_X509_STORE_CTX_get_explicit_policy
+_libre_X509_STORE_CTX_get_num_untrusted
+_libre_X509_STORE_CTX_get0_param
+_libre_X509_STORE_CTX_set0_param
+_libre_X509_STORE_CTX_set_default
+_libre_X509_VERIFY_PARAM_new
+_libre_X509_VERIFY_PARAM_free
+_libre_X509_VERIFY_PARAM_inherit
+_libre_X509_VERIFY_PARAM_set1
+_libre_X509_VERIFY_PARAM_set1_name
+_libre_X509_VERIFY_PARAM_set_flags
+_libre_X509_VERIFY_PARAM_clear_flags
+_libre_X509_VERIFY_PARAM_get_flags
+_libre_X509_VERIFY_PARAM_set_purpose
+_libre_X509_VERIFY_PARAM_set_trust
+_libre_X509_VERIFY_PARAM_set_depth
+_libre_X509_VERIFY_PARAM_set_auth_level
+_libre_X509_VERIFY_PARAM_get_time
+_libre_X509_VERIFY_PARAM_set_time
+_libre_X509_VERIFY_PARAM_add0_policy
+_libre_X509_VERIFY_PARAM_set1_policies
+_libre_X509_VERIFY_PARAM_get_depth
+_libre_X509_VERIFY_PARAM_set1_host
+_libre_X509_VERIFY_PARAM_add1_host
+_libre_X509_VERIFY_PARAM_set_hostflags
+_libre_X509_VERIFY_PARAM_get0_peername
+_libre_X509_VERIFY_PARAM_set1_email
+_libre_X509_VERIFY_PARAM_set1_ip
+_libre_X509_VERIFY_PARAM_set1_ip_asc
+_libre_X509_VERIFY_PARAM_get0_name
+_libre_X509_VERIFY_PARAM_get0
+_libre_X509_VERIFY_PARAM_get_count
+_libre_X509_VERIFY_PARAM_add0_table
+_libre_X509_VERIFY_PARAM_lookup
+_libre_X509_VERIFY_PARAM_table_cleanup
+_libre_X509_policy_check
+_libre_X509_policy_tree_free
+_libre_X509_policy_tree_level_count
+_libre_X509_policy_tree_get0_level
+_libre_X509_policy_tree_get0_policies
+_libre_X509_policy_tree_get0_user_policies
+_libre_X509_policy_level_node_count
+_libre_X509_policy_level_get0_node
+_libre_X509_policy_node_get0_policy
+_libre_X509_policy_node_get0_qualifiers
+_libre_X509_policy_node_get0_parent
+_libre_PROXY_POLICY_new
+_libre_PROXY_POLICY_free
+_libre_d2i_PROXY_POLICY
+_libre_i2d_PROXY_POLICY
+_libre_PROXY_CERT_INFO_EXTENSION_new
+_libre_PROXY_CERT_INFO_EXTENSION_free
+_libre_d2i_PROXY_CERT_INFO_EXTENSION
+_libre_i2d_PROXY_CERT_INFO_EXTENSION
+_libre_BASIC_CONSTRAINTS_new
+_libre_BASIC_CONSTRAINTS_free
+_libre_d2i_BASIC_CONSTRAINTS
+_libre_i2d_BASIC_CONSTRAINTS
+_libre_SXNET_new
+_libre_SXNET_free
+_libre_d2i_SXNET
+_libre_i2d_SXNET
+_libre_SXNETID_new
+_libre_SXNETID_free
+_libre_d2i_SXNETID
+_libre_i2d_SXNETID
+_libre_SXNET_add_id_asc
+_libre_SXNET_add_id_ulong
+_libre_SXNET_add_id_INTEGER
+_libre_SXNET_get_id_asc
+_libre_SXNET_get_id_ulong
+_libre_SXNET_get_id_INTEGER
+_libre_AUTHORITY_KEYID_new
+_libre_AUTHORITY_KEYID_free
+_libre_d2i_AUTHORITY_KEYID
+_libre_i2d_AUTHORITY_KEYID
+_libre_PKEY_USAGE_PERIOD_new
+_libre_PKEY_USAGE_PERIOD_free
+_libre_d2i_PKEY_USAGE_PERIOD
+_libre_i2d_PKEY_USAGE_PERIOD
+_libre_GENERAL_NAME_new
+_libre_GENERAL_NAME_free
+_libre_d2i_GENERAL_NAME
+_libre_i2d_GENERAL_NAME
+_libre_GENERAL_NAME_dup
+_libre_GENERAL_NAME_cmp
+_libre_v2i_ASN1_BIT_STRING
+_libre_i2v_ASN1_BIT_STRING
+_libre_i2v_GENERAL_NAME
+_libre_GENERAL_NAME_print
+_libre_GENERAL_NAMES_new
+_libre_GENERAL_NAMES_free
+_libre_d2i_GENERAL_NAMES
+_libre_i2d_GENERAL_NAMES
+_libre_i2v_GENERAL_NAMES
+_libre_v2i_GENERAL_NAMES
+_libre_OTHERNAME_new
+_libre_OTHERNAME_free
+_libre_d2i_OTHERNAME
+_libre_i2d_OTHERNAME
+_libre_EDIPARTYNAME_new
+_libre_EDIPARTYNAME_free
+_libre_d2i_EDIPARTYNAME
+_libre_i2d_EDIPARTYNAME
+_libre_OTHERNAME_cmp
+_libre_GENERAL_NAME_set0_value
+_libre_GENERAL_NAME_get0_value
+_libre_GENERAL_NAME_set0_othername
+_libre_GENERAL_NAME_get0_otherName
+_libre_i2s_ASN1_OCTET_STRING
+_libre_s2i_ASN1_OCTET_STRING
+_libre_EXTENDED_KEY_USAGE_new
+_libre_EXTENDED_KEY_USAGE_free
+_libre_d2i_EXTENDED_KEY_USAGE
+_libre_i2d_EXTENDED_KEY_USAGE
+_libre_i2a_ACCESS_DESCRIPTION
+_libre_CERTIFICATEPOLICIES_new
+_libre_CERTIFICATEPOLICIES_free
+_libre_d2i_CERTIFICATEPOLICIES
+_libre_i2d_CERTIFICATEPOLICIES
+_libre_POLICYINFO_new
+_libre_POLICYINFO_free
+_libre_d2i_POLICYINFO
+_libre_i2d_POLICYINFO
+_libre_POLICYQUALINFO_new
+_libre_POLICYQUALINFO_free
+_libre_d2i_POLICYQUALINFO
+_libre_i2d_POLICYQUALINFO
+_libre_USERNOTICE_new
+_libre_USERNOTICE_free
+_libre_d2i_USERNOTICE
+_libre_i2d_USERNOTICE
+_libre_NOTICEREF_new
+_libre_NOTICEREF_free
+_libre_d2i_NOTICEREF
+_libre_i2d_NOTICEREF
+_libre_CRL_DIST_POINTS_new
+_libre_CRL_DIST_POINTS_free
+_libre_d2i_CRL_DIST_POINTS
+_libre_i2d_CRL_DIST_POINTS
+_libre_DIST_POINT_new
+_libre_DIST_POINT_free
+_libre_d2i_DIST_POINT
+_libre_i2d_DIST_POINT
+_libre_DIST_POINT_NAME_new
+_libre_DIST_POINT_NAME_free
+_libre_d2i_DIST_POINT_NAME
+_libre_i2d_DIST_POINT_NAME
+_libre_ISSUING_DIST_POINT_new
+_libre_ISSUING_DIST_POINT_free
+_libre_d2i_ISSUING_DIST_POINT
+_libre_i2d_ISSUING_DIST_POINT
+_libre_DIST_POINT_set_dpname
+_libre_NAME_CONSTRAINTS_check
+_libre_ACCESS_DESCRIPTION_new
+_libre_ACCESS_DESCRIPTION_free
+_libre_d2i_ACCESS_DESCRIPTION
+_libre_i2d_ACCESS_DESCRIPTION
+_libre_AUTHORITY_INFO_ACCESS_new
+_libre_AUTHORITY_INFO_ACCESS_free
+_libre_d2i_AUTHORITY_INFO_ACCESS
+_libre_i2d_AUTHORITY_INFO_ACCESS
+_libre_POLICY_MAPPING_new
+_libre_POLICY_MAPPING_free
+_libre_GENERAL_SUBTREE_new
+_libre_GENERAL_SUBTREE_free
+_libre_NAME_CONSTRAINTS_new
+_libre_NAME_CONSTRAINTS_free
+_libre_POLICY_CONSTRAINTS_new
+_libre_POLICY_CONSTRAINTS_free
+_libre_a2i_GENERAL_NAME
+_libre_v2i_GENERAL_NAME
+_libre_v2i_GENERAL_NAME_ex
+_libre_X509V3_conf_free
+_libre_X509V3_EXT_nconf_nid
+_libre_X509V3_EXT_nconf
+_libre_X509V3_EXT_add_nconf_sk
+_libre_X509V3_EXT_add_nconf
+_libre_X509V3_EXT_REQ_add_nconf
+_libre_X509V3_EXT_CRL_add_nconf
+_libre_X509V3_EXT_conf_nid
+_libre_X509V3_EXT_conf
+_libre_X509V3_EXT_add_conf
+_libre_X509V3_EXT_REQ_add_conf
+_libre_X509V3_EXT_CRL_add_conf
+_libre_X509V3_add_value_bool_nf
+_libre_X509V3_get_value_bool
+_libre_X509V3_get_value_int
+_libre_X509V3_set_nconf
+_libre_X509V3_set_conf_lhash
+_libre_X509V3_get_string
+_libre_X509V3_get_section
+_libre_X509V3_string_free
+_libre_X509V3_section_free
+_libre_X509V3_set_ctx
+_libre_X509V3_add_value
+_libre_X509V3_add_value_uchar
+_libre_X509V3_add_value_bool
+_libre_X509V3_add_value_int
+_libre_i2s_ASN1_INTEGER
+_libre_s2i_ASN1_INTEGER
+_libre_i2s_ASN1_ENUMERATED
+_libre_i2s_ASN1_ENUMERATED_TABLE
+_libre_X509V3_EXT_add
+_libre_X509V3_EXT_add_list
+_libre_X509V3_EXT_add_alias
+_libre_X509V3_EXT_cleanup
+_libre_X509V3_EXT_get
+_libre_X509V3_EXT_get_nid
+_libre_X509V3_add_standard_extensions
+_libre_X509V3_parse_list
+_libre_X509V3_EXT_d2i
+_libre_X509V3_get_d2i
+_libre_X509V3_EXT_i2d
+_libre_X509V3_add1_i2d
+_libre_hex_to_string
+_libre_string_to_hex
+_libre_X509V3_EXT_val_prn
+_libre_X509V3_EXT_print
+_libre_X509V3_EXT_print_fp
+_libre_X509V3_extensions_print
+_libre_X509_check_ca
+_libre_X509_check_purpose
+_libre_X509_supported_extension
+_libre_X509_PURPOSE_set
+_libre_X509_check_issued
+_libre_X509_check_akid
+_libre_X509_PURPOSE_get_count
+_libre_X509_PURPOSE_get0
+_libre_X509_PURPOSE_get_by_sname
+_libre_X509_PURPOSE_get_by_id
+_libre_X509_PURPOSE_add
+_libre_X509_PURPOSE_get0_name
+_libre_X509_PURPOSE_get0_sname
+_libre_X509_PURPOSE_get_trust
+_libre_X509_PURPOSE_cleanup
+_libre_X509_PURPOSE_get_id
+_libre_X509_get_extension_flags
+_libre_X509_get_key_usage
+_libre_X509_get_extended_key_usage
+_libre_X509_get1_email
+_libre_X509_REQ_get1_email
+_libre_X509_email_free
+_libre_X509_get1_ocsp
+_libre_X509_check_host
+_libre_X509_check_email
+_libre_X509_check_ip
+_libre_X509_check_ip_asc
+_libre_a2i_IPADDRESS
+_libre_a2i_IPADDRESS_NC
+_libre_a2i_ipadd
+_libre_X509V3_NAME_from_section
+_libre_X509_POLICY_NODE_print
+_libre_ASRange_new
+_libre_ASRange_free
+_libre_d2i_ASRange
+_libre_i2d_ASRange
+_libre_ASIdOrRange_new
+_libre_ASIdOrRange_free
+_libre_d2i_ASIdOrRange
+_libre_i2d_ASIdOrRange
+_libre_ASIdentifierChoice_new
+_libre_ASIdentifierChoice_free
+_libre_d2i_ASIdentifierChoice
+_libre_i2d_ASIdentifierChoice
+_libre_ASIdentifiers_new
+_libre_ASIdentifiers_free
+_libre_d2i_ASIdentifiers
+_libre_i2d_ASIdentifiers
+_libre_IPAddressRange_new
+_libre_IPAddressRange_free
+_libre_d2i_IPAddressRange
+_libre_i2d_IPAddressRange
+_libre_IPAddressOrRange_new
+_libre_IPAddressOrRange_free
+_libre_d2i_IPAddressOrRange
+_libre_i2d_IPAddressOrRange
+_libre_IPAddressChoice_new
+_libre_IPAddressChoice_free
+_libre_d2i_IPAddressChoice
+_libre_i2d_IPAddressChoice
+_libre_IPAddressFamily_new
+_libre_IPAddressFamily_free
+_libre_d2i_IPAddressFamily
+_libre_i2d_IPAddressFamily
+_libre_X509v3_asid_add_inherit
+_libre_X509v3_asid_add_id_or_range
+_libre_X509v3_addr_add_inherit
+_libre_X509v3_addr_add_prefix
+_libre_X509v3_addr_add_range
+_libre_X509v3_addr_get_afi
+_libre_X509v3_addr_get_range
+_libre_X509v3_asid_is_canonical
+_libre_X509v3_addr_is_canonical
+_libre_X509v3_asid_canonize
+_libre_X509v3_addr_canonize
+_libre_X509v3_asid_inherits
+_libre_X509v3_addr_inherits
+_libre_X509v3_asid_subset
+_libre_X509v3_addr_subset
+_libre_X509v3_asid_validate_path
+_libre_X509v3_addr_validate_path
+_libre_X509v3_asid_validate_resource_set
+_libre_X509v3_addr_validate_resource_set
+_libre_ERR_load_X509V3_strings
diff --git a/src/lib/libcrypto/hidden/openssl/x509.h b/src/lib/libcrypto/hidden/openssl/x509.h
new file mode 100644
index 0000000000..59af41f917
--- /dev/null
+++ b/src/lib/libcrypto/hidden/openssl/x509.h
@@ -0,0 +1,278 @@
+/* $OpenBSD: x509.h,v 1.1 2022/11/14 17:48:49 beck Exp $ */
+/*
+ * Copyright (c) 2022 Bob Beck <beck@openbsd.org>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+#ifndef _LIBCRYPTO_X509_H
+#define _LIBCRYPTO_X509_H
+#include_next <openssl/x509.h>
+#include "crypto_namespace.h"
+LCRYPTO_USED(X509_CRL_up_ref);
+LCRYPTO_USED(i2d_re_X509_CRL_tbs);
+LCRYPTO_USED(X509_get_X509_PUBKEY);
+LCRYPTO_USED(X509_verify_cert_error_string);
+LCRYPTO_USED(X509_verify);
+LCRYPTO_USED(X509_REQ_verify);
+LCRYPTO_USED(NETSCAPE_SPKI_verify);
+LCRYPTO_USED(NETSCAPE_SPKI_b64_decode);
+LCRYPTO_USED(NETSCAPE_SPKI_b64_encode);
+LCRYPTO_USED(NETSCAPE_SPKI_get_pubkey);
+LCRYPTO_USED(NETSCAPE_SPKI_set_pubkey);
+LCRYPTO_USED(X509_sign);
+LCRYPTO_USED(X509_sign_ctx);
+LCRYPTO_USED(X509_REQ_sign);
+LCRYPTO_USED(X509_REQ_sign_ctx);
+LCRYPTO_USED(X509_CRL_sign);
+LCRYPTO_USED(X509_CRL_sign_ctx);
+LCRYPTO_USED(NETSCAPE_SPKI_sign);
+LCRYPTO_USED(X509_pubkey_digest);
+LCRYPTO_USED(X509_digest);
+LCRYPTO_USED(X509_CRL_digest);
+LCRYPTO_USED(X509_REQ_digest);
+LCRYPTO_USED(X509_NAME_digest);
+LCRYPTO_USED(d2i_X509_fp);
+LCRYPTO_USED(i2d_X509_fp);
+LCRYPTO_USED(d2i_X509_CRL_fp);
+LCRYPTO_USED(i2d_X509_CRL_fp);
+LCRYPTO_USED(d2i_X509_REQ_fp);
+LCRYPTO_USED(i2d_X509_REQ_fp);
+LCRYPTO_USED(d2i_RSAPrivateKey_fp);
+LCRYPTO_USED(i2d_RSAPrivateKey_fp);
+LCRYPTO_USED(d2i_RSAPublicKey_fp);
+LCRYPTO_USED(i2d_RSAPublicKey_fp);
+LCRYPTO_USED(d2i_DSAPrivateKey_fp);
+LCRYPTO_USED(i2d_DSAPrivateKey_fp);
+LCRYPTO_USED(d2i_ECPrivateKey_fp);
+LCRYPTO_USED(i2d_ECPrivateKey_fp);
+LCRYPTO_USED(d2i_PKCS8_fp);
+LCRYPTO_USED(i2d_PKCS8_fp);
+LCRYPTO_USED(d2i_PKCS8_PRIV_KEY_INFO_fp);
+LCRYPTO_USED(i2d_PKCS8_PRIV_KEY_INFO_fp);
+LCRYPTO_USED(i2d_PKCS8PrivateKeyInfo_fp);
+LCRYPTO_USED(i2d_PrivateKey_fp);
+LCRYPTO_USED(d2i_PrivateKey_fp);
+LCRYPTO_USED(d2i_X509_bio);
+LCRYPTO_USED(i2d_X509_bio);
+LCRYPTO_USED(d2i_X509_CRL_bio);
+LCRYPTO_USED(i2d_X509_CRL_bio);
+LCRYPTO_USED(d2i_X509_REQ_bio);
+LCRYPTO_USED(i2d_X509_REQ_bio);
+LCRYPTO_USED(d2i_RSAPrivateKey_bio);
+LCRYPTO_USED(i2d_RSAPrivateKey_bio);
+LCRYPTO_USED(d2i_RSAPublicKey_bio);
+LCRYPTO_USED(i2d_RSAPublicKey_bio);
+LCRYPTO_USED(d2i_DSAPrivateKey_bio);
+LCRYPTO_USED(i2d_DSAPrivateKey_bio);
+LCRYPTO_USED(d2i_ECPrivateKey_bio);
+LCRYPTO_USED(i2d_ECPrivateKey_bio);
+LCRYPTO_USED(d2i_PKCS8_bio);
+LCRYPTO_USED(i2d_PKCS8_bio);
+LCRYPTO_USED(d2i_PKCS8_PRIV_KEY_INFO_bio);
+LCRYPTO_USED(i2d_PKCS8_PRIV_KEY_INFO_bio);
+LCRYPTO_USED(i2d_PKCS8PrivateKeyInfo_bio);
+LCRYPTO_USED(i2d_PrivateKey_bio);
+LCRYPTO_USED(d2i_PrivateKey_bio);
+LCRYPTO_USED(X509_cmp_time);
+LCRYPTO_USED(X509_cmp_current_time);
+LCRYPTO_USED(X509_time_adj);
+LCRYPTO_USED(X509_time_adj_ex);
+LCRYPTO_USED(X509_gmtime_adj);
+LCRYPTO_USED(X509_get_default_cert_area);
+LCRYPTO_USED(X509_get_default_cert_dir);
+LCRYPTO_USED(X509_get_default_cert_file);
+LCRYPTO_USED(X509_get_default_cert_dir_env);
+LCRYPTO_USED(X509_get_default_cert_file_env);
+LCRYPTO_USED(X509_get_default_private_dir);
+LCRYPTO_USED(X509_to_X509_REQ);
+LCRYPTO_USED(X509_REQ_to_X509);
+LCRYPTO_USED(X509_get_pubkey_parameters);
+LCRYPTO_USED(X509_TRUST_set_default);
+LCRYPTO_USED(X509_TRUST_set);
+LCRYPTO_USED(X509_NAME_oneline);
+LCRYPTO_USED(X509_get0_extensions);
+LCRYPTO_USED(X509_get0_tbs_sigalg);
+LCRYPTO_USED(X509_set_version);
+LCRYPTO_USED(X509_get_version);
+LCRYPTO_USED(X509_set_serialNumber);
+LCRYPTO_USED(X509_get_serialNumber);
+LCRYPTO_USED(X509_get0_serialNumber);
+LCRYPTO_USED(X509_set_issuer_name);
+LCRYPTO_USED(X509_get_issuer_name);
+LCRYPTO_USED(X509_set_subject_name);
+LCRYPTO_USED(X509_get_subject_name);
+LCRYPTO_USED(X509_set_notBefore);
+LCRYPTO_USED(X509_set1_notBefore);
+LCRYPTO_USED(X509_set_notAfter);
+LCRYPTO_USED(X509_set1_notAfter);
+LCRYPTO_USED(X509_get0_notBefore);
+LCRYPTO_USED(X509_getm_notBefore);
+LCRYPTO_USED(X509_get0_notAfter);
+LCRYPTO_USED(X509_getm_notAfter);
+LCRYPTO_USED(X509_set_pubkey);
+LCRYPTO_USED(X509_get_pubkey);
+LCRYPTO_USED(X509_get0_pubkey);
+LCRYPTO_USED(X509_get0_pubkey_bitstr);
+LCRYPTO_USED(X509_certificate_type);
+LCRYPTO_USED(X509_get_signature_type);
+LCRYPTO_USED(X509_REQ_set_version);
+LCRYPTO_USED(X509_REQ_get_version);
+LCRYPTO_USED(X509_REQ_set_subject_name);
+LCRYPTO_USED(X509_REQ_get_subject_name);
+LCRYPTO_USED(X509_REQ_set_pubkey);
+LCRYPTO_USED(X509_REQ_get_pubkey);
+LCRYPTO_USED(i2d_re_X509_REQ_tbs);
+LCRYPTO_USED(X509_REQ_get0_pubkey);
+LCRYPTO_USED(X509_REQ_extension_nid);
+LCRYPTO_USED(X509_REQ_get_extension_nids);
+LCRYPTO_USED(X509_REQ_set_extension_nids);
+LCRYPTO_USED(X509_REQ_get_extensions);
+LCRYPTO_USED(X509_REQ_add_extensions_nid);
+LCRYPTO_USED(X509_REQ_add_extensions);
+LCRYPTO_USED(X509_REQ_get_attr_count);
+LCRYPTO_USED(X509_REQ_get_attr_by_NID);
+LCRYPTO_USED(X509_REQ_get_attr_by_OBJ);
+LCRYPTO_USED(X509_REQ_get_attr);
+LCRYPTO_USED(X509_REQ_delete_attr);
+LCRYPTO_USED(X509_REQ_add1_attr);
+LCRYPTO_USED(X509_REQ_add1_attr_by_OBJ);
+LCRYPTO_USED(X509_REQ_add1_attr_by_NID);
+LCRYPTO_USED(X509_REQ_add1_attr_by_txt);
+LCRYPTO_USED(X509_CRL_set_version);
+LCRYPTO_USED(X509_CRL_set_issuer_name);
+LCRYPTO_USED(X509_CRL_set_lastUpdate);
+LCRYPTO_USED(X509_CRL_set1_lastUpdate);
+LCRYPTO_USED(X509_CRL_set_nextUpdate);
+LCRYPTO_USED(X509_CRL_set1_nextUpdate);
+LCRYPTO_USED(X509_CRL_sort);
+LCRYPTO_USED(X509_REVOKED_get0_extensions);
+LCRYPTO_USED(X509_REVOKED_get0_revocationDate);
+LCRYPTO_USED(X509_REVOKED_get0_serialNumber);
+LCRYPTO_USED(X509_REVOKED_set_revocationDate);
+LCRYPTO_USED(X509_REVOKED_set_serialNumber);
+LCRYPTO_USED(X509_REQ_check_private_key);
+LCRYPTO_USED(X509_check_private_key);
+LCRYPTO_USED(X509_issuer_and_serial_cmp);
+LCRYPTO_USED(X509_issuer_and_serial_hash);
+LCRYPTO_USED(X509_issuer_name_cmp);
+LCRYPTO_USED(X509_issuer_name_hash);
+LCRYPTO_USED(X509_subject_name_cmp);
+LCRYPTO_USED(X509_subject_name_hash);
+LCRYPTO_USED(X509_issuer_name_hash_old);
+LCRYPTO_USED(X509_subject_name_hash_old);
+LCRYPTO_USED(X509_cmp);
+LCRYPTO_USED(X509_NAME_cmp);
+LCRYPTO_USED(X509_NAME_hash);
+LCRYPTO_USED(X509_NAME_hash_old);
+LCRYPTO_USED(X509_CRL_cmp);
+LCRYPTO_USED(X509_CRL_match);
+LCRYPTO_USED(X509_NAME_entry_count);
+LCRYPTO_USED(X509_NAME_get_text_by_NID);
+LCRYPTO_USED(X509_NAME_get_text_by_OBJ);
+LCRYPTO_USED(X509_NAME_get_index_by_NID);
+LCRYPTO_USED(X509_NAME_get_index_by_OBJ);
+LCRYPTO_USED(X509_NAME_get_entry);
+LCRYPTO_USED(X509_NAME_delete_entry);
+LCRYPTO_USED(X509_NAME_add_entry);
+LCRYPTO_USED(X509_NAME_add_entry_by_OBJ);
+LCRYPTO_USED(X509_NAME_add_entry_by_NID);
+LCRYPTO_USED(X509_NAME_ENTRY_create_by_txt);
+LCRYPTO_USED(X509_NAME_ENTRY_create_by_NID);
+LCRYPTO_USED(X509_NAME_add_entry_by_txt);
+LCRYPTO_USED(X509_NAME_ENTRY_create_by_OBJ);
+LCRYPTO_USED(X509_NAME_ENTRY_set_object);
+LCRYPTO_USED(X509_NAME_ENTRY_set_data);
+LCRYPTO_USED(X509_NAME_ENTRY_get_object);
+LCRYPTO_USED(X509_NAME_ENTRY_get_data);
+LCRYPTO_USED(X509_NAME_ENTRY_set);
+LCRYPTO_USED(X509v3_get_ext_count);
+LCRYPTO_USED(X509v3_get_ext_by_NID);
+LCRYPTO_USED(X509v3_get_ext_by_OBJ);
+LCRYPTO_USED(X509v3_get_ext_by_critical);
+LCRYPTO_USED(X509v3_get_ext);
+LCRYPTO_USED(X509v3_delete_ext);
+LCRYPTO_USED(X509v3_add_ext);
+LCRYPTO_USED(X509_get_ext_count);
+LCRYPTO_USED(X509_get_ext_by_NID);
+LCRYPTO_USED(X509_get_ext_by_OBJ);
+LCRYPTO_USED(X509_get_ext_by_critical);
+LCRYPTO_USED(X509_get_ext);
+LCRYPTO_USED(X509_delete_ext);
+LCRYPTO_USED(X509_add_ext);
+LCRYPTO_USED(X509_get_ext_d2i);
+LCRYPTO_USED(X509_add1_ext_i2d);
+LCRYPTO_USED(X509_CRL_get_ext_count);
+LCRYPTO_USED(X509_CRL_get_ext_by_NID);
+LCRYPTO_USED(X509_CRL_get_ext_by_OBJ);
+LCRYPTO_USED(X509_CRL_get_ext_by_critical);
+LCRYPTO_USED(X509_CRL_get_ext);
+LCRYPTO_USED(X509_CRL_delete_ext);
+LCRYPTO_USED(X509_CRL_add_ext);
+LCRYPTO_USED(X509_CRL_get_ext_d2i);
+LCRYPTO_USED(X509_CRL_add1_ext_i2d);
+LCRYPTO_USED(X509_REVOKED_get_ext_count);
+LCRYPTO_USED(X509_REVOKED_get_ext_by_NID);
+LCRYPTO_USED(X509_REVOKED_get_ext_by_OBJ);
+LCRYPTO_USED(X509_REVOKED_get_ext_by_critical);
+LCRYPTO_USED(X509_REVOKED_get_ext);
+LCRYPTO_USED(X509_REVOKED_delete_ext);
+LCRYPTO_USED(X509_REVOKED_add_ext);
+LCRYPTO_USED(X509_REVOKED_get_ext_d2i);
+LCRYPTO_USED(X509_REVOKED_add1_ext_i2d);
+LCRYPTO_USED(X509_EXTENSION_create_by_NID);
+LCRYPTO_USED(X509_EXTENSION_create_by_OBJ);
+LCRYPTO_USED(X509_EXTENSION_set_object);
+LCRYPTO_USED(X509_EXTENSION_set_critical);
+LCRYPTO_USED(X509_EXTENSION_set_data);
+LCRYPTO_USED(X509_EXTENSION_get_object);
+LCRYPTO_USED(X509_EXTENSION_get_data);
+LCRYPTO_USED(X509_EXTENSION_get_critical);
+LCRYPTO_USED(X509at_get_attr_count);
+LCRYPTO_USED(X509at_get_attr_by_NID);
+LCRYPTO_USED(X509at_get_attr_by_OBJ);
+LCRYPTO_USED(X509at_get_attr);
+LCRYPTO_USED(X509at_delete_attr);
+LCRYPTO_USED(X509at_add1_attr);
+LCRYPTO_USED(X509at_add1_attr_by_OBJ);
+LCRYPTO_USED(X509at_add1_attr_by_NID);
+LCRYPTO_USED(X509at_add1_attr_by_txt);
+LCRYPTO_USED(X509at_get0_data_by_OBJ);
+LCRYPTO_USED(X509_ATTRIBUTE_create_by_NID);
+LCRYPTO_USED(X509_ATTRIBUTE_create_by_OBJ);
+LCRYPTO_USED(X509_ATTRIBUTE_create_by_txt);
+LCRYPTO_USED(X509_ATTRIBUTE_set1_object);
+LCRYPTO_USED(X509_ATTRIBUTE_set1_data);
+LCRYPTO_USED(X509_ATTRIBUTE_get0_data);
+LCRYPTO_USED(X509_ATTRIBUTE_count);
+LCRYPTO_USED(X509_ATTRIBUTE_get0_object);
+LCRYPTO_USED(X509_ATTRIBUTE_get0_type);
+LCRYPTO_USED(X509_verify_cert);
+LCRYPTO_USED(X509_find_by_issuer_and_serial);
+LCRYPTO_USED(X509_find_by_subject);
+LCRYPTO_USED(X509_check_trust);
+LCRYPTO_USED(X509_TRUST_get_count);
+LCRYPTO_USED(X509_TRUST_get0);
+LCRYPTO_USED(X509_TRUST_get_by_id);
+LCRYPTO_USED(X509_TRUST_add);
+LCRYPTO_USED(X509_TRUST_cleanup);
+LCRYPTO_USED(X509_TRUST_get_flags);
+LCRYPTO_USED(X509_TRUST_get0_name);
+LCRYPTO_USED(X509_TRUST_get_trust);
+LCRYPTO_USED(X509_up_ref);
+LCRYPTO_USED(X509_chain_up_ref);
+LCRYPTO_USED(ERR_load_X509_strings);
+#endif /* _LIBCRYPTO_X509_H */
diff --git a/src/lib/libcrypto/hidden/openssl/x509_vfy.h b/src/lib/libcrypto/hidden/openssl/x509_vfy.h
new file mode 100644
index 0000000000..3a52206b45
--- /dev/null
+++ b/src/lib/libcrypto/hidden/openssl/x509_vfy.h
@@ -0,0 +1,162 @@
+/* $OpenBSD: x509_vfy.h,v 1.1 2022/11/14 17:48:49 beck Exp $ */
+/*
+ * Copyright (c) 2022 Bob Beck <beck@openbsd.org>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+#ifndef _LIBCRYPTO_X509_VFY_H
+#define _LIBCRYPTO_X509_VFY_H
+#include_next <openssl/x509_vfy.h>
+#include "crypto_namespace.h"
+LCRYPTO_USED(X509_STORE_set_depth);
+LCRYPTO_USED(X509_STORE_CTX_set_depth);
+LCRYPTO_USED(X509_OBJECT_new);
+LCRYPTO_USED(X509_OBJECT_free);
+LCRYPTO_USED(X509_OBJECT_idx_by_subject);
+LCRYPTO_USED(X509_OBJECT_retrieve_by_subject);
+LCRYPTO_USED(X509_OBJECT_retrieve_match);
+LCRYPTO_USED(X509_OBJECT_up_ref_count);
+LCRYPTO_USED(X509_OBJECT_get_type);
+LCRYPTO_USED(X509_OBJECT_get0_X509);
+LCRYPTO_USED(X509_OBJECT_get0_X509_CRL);
+LCRYPTO_USED(X509_STORE_new);
+LCRYPTO_USED(X509_STORE_free);
+LCRYPTO_USED(X509_STORE_up_ref);
+LCRYPTO_USED(X509_STORE_get1_certs);
+LCRYPTO_USED(X509_STORE_get1_crls);
+LCRYPTO_USED(X509_STORE_get0_objects);
+LCRYPTO_USED(X509_STORE_get_ex_data);
+LCRYPTO_USED(X509_STORE_set_ex_data);
+LCRYPTO_USED(X509_STORE_set_flags);
+LCRYPTO_USED(X509_STORE_set_purpose);
+LCRYPTO_USED(X509_STORE_set_trust);
+LCRYPTO_USED(X509_STORE_set1_param);
+LCRYPTO_USED(X509_STORE_get0_param);
+LCRYPTO_USED(X509_STORE_get_verify_cb);
+LCRYPTO_USED(X509_STORE_set_verify_cb);
+LCRYPTO_USED(X509_STORE_CTX_new);
+LCRYPTO_USED(X509_STORE_CTX_get1_issuer);
+LCRYPTO_USED(X509_STORE_CTX_free);
+LCRYPTO_USED(X509_STORE_CTX_init);
+LCRYPTO_USED(X509_STORE_CTX_get0_cert);
+LCRYPTO_USED(X509_STORE_CTX_get0_chain);
+LCRYPTO_USED(X509_STORE_CTX_get0_store);
+LCRYPTO_USED(X509_STORE_CTX_get0_untrusted);
+LCRYPTO_USED(X509_STORE_CTX_set0_untrusted);
+LCRYPTO_USED(X509_STORE_CTX_trusted_stack);
+LCRYPTO_USED(X509_STORE_CTX_set0_trusted_stack);
+LCRYPTO_USED(X509_STORE_CTX_cleanup);
+LCRYPTO_USED(X509_STORE_add_lookup);
+LCRYPTO_USED(X509_LOOKUP_hash_dir);
+LCRYPTO_USED(X509_LOOKUP_file);
+LCRYPTO_USED(X509_LOOKUP_mem);
+LCRYPTO_USED(X509_STORE_add_cert);
+LCRYPTO_USED(X509_STORE_add_crl);
+LCRYPTO_USED(X509_STORE_CTX_get_by_subject);
+LCRYPTO_USED(X509_STORE_CTX_get_obj_by_subject);
+LCRYPTO_USED(X509_LOOKUP_ctrl);
+LCRYPTO_USED(X509_load_cert_file);
+LCRYPTO_USED(X509_load_crl_file);
+LCRYPTO_USED(X509_load_cert_crl_file);
+LCRYPTO_USED(X509_LOOKUP_new);
+LCRYPTO_USED(X509_LOOKUP_free);
+LCRYPTO_USED(X509_LOOKUP_init);
+LCRYPTO_USED(X509_LOOKUP_by_subject);
+LCRYPTO_USED(X509_LOOKUP_by_issuer_serial);
+LCRYPTO_USED(X509_LOOKUP_by_fingerprint);
+LCRYPTO_USED(X509_LOOKUP_by_alias);
+LCRYPTO_USED(X509_LOOKUP_shutdown);
+LCRYPTO_USED(X509_STORE_load_locations);
+LCRYPTO_USED(X509_STORE_load_mem);
+LCRYPTO_USED(X509_STORE_set_default_paths);
+LCRYPTO_USED(X509_STORE_CTX_get_ex_new_index);
+LCRYPTO_USED(X509_STORE_CTX_set_ex_data);
+LCRYPTO_USED(X509_STORE_CTX_get_ex_data);
+LCRYPTO_USED(X509_STORE_CTX_get_error);
+LCRYPTO_USED(X509_STORE_CTX_set_error);
+LCRYPTO_USED(X509_STORE_CTX_get_error_depth);
+LCRYPTO_USED(X509_STORE_CTX_set_error_depth);
+LCRYPTO_USED(X509_STORE_CTX_get_current_cert);
+LCRYPTO_USED(X509_STORE_CTX_set_current_cert);
+LCRYPTO_USED(X509_STORE_CTX_get0_current_issuer);
+LCRYPTO_USED(X509_STORE_CTX_get0_current_crl);
+LCRYPTO_USED(X509_STORE_CTX_get0_parent_ctx);
+LCRYPTO_USED(X509_STORE_CTX_get_chain);
+LCRYPTO_USED(X509_STORE_CTX_get1_chain);
+LCRYPTO_USED(X509_STORE_CTX_set_cert);
+LCRYPTO_USED(X509_STORE_CTX_set_chain);
+LCRYPTO_USED(X509_STORE_CTX_set0_crls);
+LCRYPTO_USED(X509_STORE_CTX_set_purpose);
+LCRYPTO_USED(X509_STORE_CTX_set_trust);
+LCRYPTO_USED(X509_STORE_CTX_purpose_inherit);
+LCRYPTO_USED(X509_STORE_CTX_set_flags);
+LCRYPTO_USED(X509_STORE_CTX_set_time);
+LCRYPTO_USED(X509_STORE_CTX_set0_verified_chain);
+LCRYPTO_USED(X509_STORE_CTX_get_verify);
+LCRYPTO_USED(X509_STORE_CTX_set_verify);
+LCRYPTO_USED(X509_STORE_CTX_get_verify_cb);
+LCRYPTO_USED(X509_STORE_CTX_set_verify_cb);
+LCRYPTO_USED(X509_STORE_set_verify);
+LCRYPTO_USED(X509_STORE_get_verify);
+LCRYPTO_USED(X509_STORE_CTX_get0_policy_tree);
+LCRYPTO_USED(X509_STORE_CTX_get_explicit_policy);
+LCRYPTO_USED(X509_STORE_CTX_get_num_untrusted);
+LCRYPTO_USED(X509_STORE_CTX_get0_param);
+LCRYPTO_USED(X509_STORE_CTX_set0_param);
+LCRYPTO_USED(X509_STORE_CTX_set_default);
+LCRYPTO_USED(X509_VERIFY_PARAM_new);
+LCRYPTO_USED(X509_VERIFY_PARAM_free);
+LCRYPTO_USED(X509_VERIFY_PARAM_inherit);
+LCRYPTO_USED(X509_VERIFY_PARAM_set1);
+LCRYPTO_USED(X509_VERIFY_PARAM_set1_name);
+LCRYPTO_USED(X509_VERIFY_PARAM_set_flags);
+LCRYPTO_USED(X509_VERIFY_PARAM_clear_flags);
+LCRYPTO_USED(X509_VERIFY_PARAM_get_flags);
+LCRYPTO_USED(X509_VERIFY_PARAM_set_purpose);
+LCRYPTO_USED(X509_VERIFY_PARAM_set_trust);
+LCRYPTO_USED(X509_VERIFY_PARAM_set_depth);
+LCRYPTO_USED(X509_VERIFY_PARAM_set_auth_level);
+LCRYPTO_USED(X509_VERIFY_PARAM_get_time);
+LCRYPTO_USED(X509_VERIFY_PARAM_set_time);
+LCRYPTO_USED(X509_VERIFY_PARAM_add0_policy);
+LCRYPTO_USED(X509_VERIFY_PARAM_set1_policies);
+LCRYPTO_USED(X509_VERIFY_PARAM_get_depth);
+LCRYPTO_USED(X509_VERIFY_PARAM_set1_host);
+LCRYPTO_USED(X509_VERIFY_PARAM_add1_host);
+LCRYPTO_USED(X509_VERIFY_PARAM_set_hostflags);
+LCRYPTO_USED(X509_VERIFY_PARAM_get0_peername);
+LCRYPTO_USED(X509_VERIFY_PARAM_set1_email);
+LCRYPTO_USED(X509_VERIFY_PARAM_set1_ip);
+LCRYPTO_USED(X509_VERIFY_PARAM_set1_ip_asc);
+LCRYPTO_USED(X509_VERIFY_PARAM_get0_name);
+LCRYPTO_USED(X509_VERIFY_PARAM_get0);
+LCRYPTO_USED(X509_VERIFY_PARAM_get_count);
+LCRYPTO_USED(X509_VERIFY_PARAM_add0_table);
+LCRYPTO_USED(X509_VERIFY_PARAM_lookup);
+LCRYPTO_USED(X509_VERIFY_PARAM_table_cleanup);
+LCRYPTO_USED(X509_policy_check);
+LCRYPTO_USED(X509_policy_tree_free);
+LCRYPTO_USED(X509_policy_tree_level_count);
+LCRYPTO_USED(X509_policy_tree_get0_level);
+LCRYPTO_USED(X509_policy_tree_get0_policies);
+LCRYPTO_USED(X509_policy_tree_get0_user_policies);
+LCRYPTO_USED(X509_policy_level_node_count);
+LCRYPTO_USED(X509_policy_level_get0_node);
+LCRYPTO_USED(X509_policy_node_get0_policy);
+LCRYPTO_USED(X509_policy_node_get0_qualifiers);
+LCRYPTO_USED(X509_policy_node_get0_parent);
+#endif /* _LIBCRYPTO_X509_VFY_H */
diff --git a/src/lib/libcrypto/hidden/openssl/x509v3.h b/src/lib/libcrypto/hidden/openssl/x509v3.h
new file mode 100644
index 0000000000..eed75e0749
--- /dev/null
+++ b/src/lib/libcrypto/hidden/openssl/x509v3.h
@@ -0,0 +1,284 @@
+/* $OpenBSD: x509v3.h,v 1.1 2022/11/14 17:48:49 beck Exp $ */
+/*
+ * Copyright (c) 2022 Bob Beck <beck@openbsd.org>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+#ifndef _LIBCRYPTO_X509V3_H
+#define _LIBCRYPTO_X509V3_H
+#include_next <openssl/x509v3.h>
+#include "crypto_namespace.h"
+LCRYPTO_USED(PROXY_POLICY_new);
+LCRYPTO_USED(PROXY_POLICY_free);
+LCRYPTO_USED(d2i_PROXY_POLICY);
+LCRYPTO_USED(i2d_PROXY_POLICY);
+LCRYPTO_USED(PROXY_CERT_INFO_EXTENSION_new);
+LCRYPTO_USED(PROXY_CERT_INFO_EXTENSION_free);
+LCRYPTO_USED(d2i_PROXY_CERT_INFO_EXTENSION);
+LCRYPTO_USED(i2d_PROXY_CERT_INFO_EXTENSION);
+LCRYPTO_USED(BASIC_CONSTRAINTS_new);
+LCRYPTO_USED(BASIC_CONSTRAINTS_free);
+LCRYPTO_USED(d2i_BASIC_CONSTRAINTS);
+LCRYPTO_USED(i2d_BASIC_CONSTRAINTS);
+LCRYPTO_USED(SXNET_new);
+LCRYPTO_USED(SXNET_free);
+LCRYPTO_USED(d2i_SXNET);
+LCRYPTO_USED(i2d_SXNET);
+LCRYPTO_USED(SXNETID_new);
+LCRYPTO_USED(SXNETID_free);
+LCRYPTO_USED(d2i_SXNETID);
+LCRYPTO_USED(i2d_SXNETID);
+LCRYPTO_USED(SXNET_add_id_asc);
+LCRYPTO_USED(SXNET_add_id_ulong);
+LCRYPTO_USED(SXNET_add_id_INTEGER);
+LCRYPTO_USED(SXNET_get_id_asc);
+LCRYPTO_USED(SXNET_get_id_ulong);
+LCRYPTO_USED(SXNET_get_id_INTEGER);
+LCRYPTO_USED(AUTHORITY_KEYID_new);
+LCRYPTO_USED(AUTHORITY_KEYID_free);
+LCRYPTO_USED(d2i_AUTHORITY_KEYID);
+LCRYPTO_USED(i2d_AUTHORITY_KEYID);
+LCRYPTO_USED(PKEY_USAGE_PERIOD_new);
+LCRYPTO_USED(PKEY_USAGE_PERIOD_free);
+LCRYPTO_USED(d2i_PKEY_USAGE_PERIOD);
+LCRYPTO_USED(i2d_PKEY_USAGE_PERIOD);
+LCRYPTO_USED(GENERAL_NAME_new);
+LCRYPTO_USED(GENERAL_NAME_free);
+LCRYPTO_USED(d2i_GENERAL_NAME);
+LCRYPTO_USED(i2d_GENERAL_NAME);
+LCRYPTO_USED(GENERAL_NAME_dup);
+LCRYPTO_USED(GENERAL_NAME_cmp);
+LCRYPTO_USED(v2i_ASN1_BIT_STRING);
+LCRYPTO_USED(i2v_ASN1_BIT_STRING);
+LCRYPTO_USED(i2v_GENERAL_NAME);
+LCRYPTO_USED(GENERAL_NAME_print);
+LCRYPTO_USED(GENERAL_NAMES_new);
+LCRYPTO_USED(GENERAL_NAMES_free);
+LCRYPTO_USED(d2i_GENERAL_NAMES);
+LCRYPTO_USED(i2d_GENERAL_NAMES);
+LCRYPTO_USED(i2v_GENERAL_NAMES);
+LCRYPTO_USED(v2i_GENERAL_NAMES);
+LCRYPTO_USED(OTHERNAME_new);
+LCRYPTO_USED(OTHERNAME_free);
+LCRYPTO_USED(d2i_OTHERNAME);
+LCRYPTO_USED(i2d_OTHERNAME);
+LCRYPTO_USED(EDIPARTYNAME_new);
+LCRYPTO_USED(EDIPARTYNAME_free);
+LCRYPTO_USED(d2i_EDIPARTYNAME);
+LCRYPTO_USED(i2d_EDIPARTYNAME);
+LCRYPTO_USED(OTHERNAME_cmp);
+LCRYPTO_USED(GENERAL_NAME_set0_value);
+LCRYPTO_USED(GENERAL_NAME_get0_value);
+LCRYPTO_USED(GENERAL_NAME_set0_othername);
+LCRYPTO_USED(GENERAL_NAME_get0_otherName);
+LCRYPTO_USED(i2s_ASN1_OCTET_STRING);
+LCRYPTO_USED(s2i_ASN1_OCTET_STRING);
+LCRYPTO_USED(EXTENDED_KEY_USAGE_new);
+LCRYPTO_USED(EXTENDED_KEY_USAGE_free);
+LCRYPTO_USED(d2i_EXTENDED_KEY_USAGE);
+LCRYPTO_USED(i2d_EXTENDED_KEY_USAGE);
+LCRYPTO_USED(i2a_ACCESS_DESCRIPTION);
+LCRYPTO_USED(CERTIFICATEPOLICIES_new);
+LCRYPTO_USED(CERTIFICATEPOLICIES_free);
+LCRYPTO_USED(d2i_CERTIFICATEPOLICIES);
+LCRYPTO_USED(i2d_CERTIFICATEPOLICIES);
+LCRYPTO_USED(POLICYINFO_new);
+LCRYPTO_USED(POLICYINFO_free);
+LCRYPTO_USED(d2i_POLICYINFO);
+LCRYPTO_USED(i2d_POLICYINFO);
+LCRYPTO_USED(POLICYQUALINFO_new);
+LCRYPTO_USED(POLICYQUALINFO_free);
+LCRYPTO_USED(d2i_POLICYQUALINFO);
+LCRYPTO_USED(i2d_POLICYQUALINFO);
+LCRYPTO_USED(USERNOTICE_new);
+LCRYPTO_USED(USERNOTICE_free);
+LCRYPTO_USED(d2i_USERNOTICE);
+LCRYPTO_USED(i2d_USERNOTICE);
+LCRYPTO_USED(NOTICEREF_new);
+LCRYPTO_USED(NOTICEREF_free);
+LCRYPTO_USED(d2i_NOTICEREF);
+LCRYPTO_USED(i2d_NOTICEREF);
+LCRYPTO_USED(CRL_DIST_POINTS_new);
+LCRYPTO_USED(CRL_DIST_POINTS_free);
+LCRYPTO_USED(d2i_CRL_DIST_POINTS);
+LCRYPTO_USED(i2d_CRL_DIST_POINTS);
+LCRYPTO_USED(DIST_POINT_new);
+LCRYPTO_USED(DIST_POINT_free);
+LCRYPTO_USED(d2i_DIST_POINT);
+LCRYPTO_USED(i2d_DIST_POINT);
+LCRYPTO_USED(DIST_POINT_NAME_new);
+LCRYPTO_USED(DIST_POINT_NAME_free);
+LCRYPTO_USED(d2i_DIST_POINT_NAME);
+LCRYPTO_USED(i2d_DIST_POINT_NAME);
+LCRYPTO_USED(ISSUING_DIST_POINT_new);
+LCRYPTO_USED(ISSUING_DIST_POINT_free);
+LCRYPTO_USED(d2i_ISSUING_DIST_POINT);
+LCRYPTO_USED(i2d_ISSUING_DIST_POINT);
+LCRYPTO_USED(DIST_POINT_set_dpname);
+LCRYPTO_USED(NAME_CONSTRAINTS_check);
+LCRYPTO_USED(ACCESS_DESCRIPTION_new);
+LCRYPTO_USED(ACCESS_DESCRIPTION_free);
+LCRYPTO_USED(d2i_ACCESS_DESCRIPTION);
+LCRYPTO_USED(i2d_ACCESS_DESCRIPTION);
+LCRYPTO_USED(AUTHORITY_INFO_ACCESS_new);
+LCRYPTO_USED(AUTHORITY_INFO_ACCESS_free);
+LCRYPTO_USED(d2i_AUTHORITY_INFO_ACCESS);
+LCRYPTO_USED(i2d_AUTHORITY_INFO_ACCESS);
+LCRYPTO_USED(POLICY_MAPPING_new);
+LCRYPTO_USED(POLICY_MAPPING_free);
+LCRYPTO_USED(GENERAL_SUBTREE_new);
+LCRYPTO_USED(GENERAL_SUBTREE_free);
+LCRYPTO_USED(NAME_CONSTRAINTS_new);
+LCRYPTO_USED(NAME_CONSTRAINTS_free);
+LCRYPTO_USED(POLICY_CONSTRAINTS_new);
+LCRYPTO_USED(POLICY_CONSTRAINTS_free);
+LCRYPTO_USED(a2i_GENERAL_NAME);
+LCRYPTO_USED(v2i_GENERAL_NAME);
+LCRYPTO_USED(v2i_GENERAL_NAME_ex);
+LCRYPTO_USED(X509V3_conf_free);
+LCRYPTO_USED(X509V3_EXT_nconf_nid);
+LCRYPTO_USED(X509V3_EXT_nconf);
+LCRYPTO_USED(X509V3_EXT_add_nconf_sk);
+LCRYPTO_USED(X509V3_EXT_add_nconf);
+LCRYPTO_USED(X509V3_EXT_REQ_add_nconf);
+LCRYPTO_USED(X509V3_EXT_CRL_add_nconf);
+LCRYPTO_USED(X509V3_EXT_conf_nid);
+LCRYPTO_USED(X509V3_EXT_conf);
+LCRYPTO_USED(X509V3_EXT_add_conf);
+LCRYPTO_USED(X509V3_EXT_REQ_add_conf);
+LCRYPTO_USED(X509V3_EXT_CRL_add_conf);
+LCRYPTO_USED(X509V3_add_value_bool_nf);
+LCRYPTO_USED(X509V3_get_value_bool);
+LCRYPTO_USED(X509V3_get_value_int);
+LCRYPTO_USED(X509V3_set_nconf);
+LCRYPTO_USED(X509V3_set_conf_lhash);
+LCRYPTO_USED(X509V3_get_string);
+LCRYPTO_USED(X509V3_get_section);
+LCRYPTO_USED(X509V3_string_free);
+LCRYPTO_USED(X509V3_section_free);
+LCRYPTO_USED(X509V3_set_ctx);
+LCRYPTO_USED(X509V3_add_value);
+LCRYPTO_USED(X509V3_add_value_uchar);
+LCRYPTO_USED(X509V3_add_value_bool);
+LCRYPTO_USED(X509V3_add_value_int);
+LCRYPTO_USED(i2s_ASN1_INTEGER);
+LCRYPTO_USED(s2i_ASN1_INTEGER);
+LCRYPTO_USED(i2s_ASN1_ENUMERATED);
+LCRYPTO_USED(i2s_ASN1_ENUMERATED_TABLE);
+LCRYPTO_USED(X509V3_EXT_add);
+LCRYPTO_USED(X509V3_EXT_add_list);
+LCRYPTO_USED(X509V3_EXT_add_alias);
+LCRYPTO_USED(X509V3_EXT_cleanup);
+LCRYPTO_USED(X509V3_EXT_get);
+LCRYPTO_USED(X509V3_EXT_get_nid);
+LCRYPTO_USED(X509V3_add_standard_extensions);
+LCRYPTO_USED(X509V3_parse_list);
+LCRYPTO_USED(X509V3_EXT_d2i);
+LCRYPTO_USED(X509V3_get_d2i);
+LCRYPTO_USED(X509V3_EXT_i2d);
+LCRYPTO_USED(X509V3_add1_i2d);
+LCRYPTO_USED(hex_to_string);
+LCRYPTO_USED(string_to_hex);
+LCRYPTO_USED(X509V3_EXT_val_prn);
+LCRYPTO_USED(X509V3_EXT_print);
+LCRYPTO_USED(X509V3_EXT_print_fp);
+LCRYPTO_USED(X509V3_extensions_print);
+LCRYPTO_USED(X509_check_ca);
+LCRYPTO_USED(X509_check_purpose);
+LCRYPTO_USED(X509_supported_extension);
+LCRYPTO_USED(X509_PURPOSE_set);
+LCRYPTO_USED(X509_check_issued);
+LCRYPTO_USED(X509_check_akid);
+LCRYPTO_USED(X509_PURPOSE_get_count);
+LCRYPTO_USED(X509_PURPOSE_get0);
+LCRYPTO_USED(X509_PURPOSE_get_by_sname);
+LCRYPTO_USED(X509_PURPOSE_get_by_id);
+LCRYPTO_USED(X509_PURPOSE_add);
+LCRYPTO_USED(X509_PURPOSE_get0_name);
+LCRYPTO_USED(X509_PURPOSE_get0_sname);
+LCRYPTO_USED(X509_PURPOSE_get_trust);
+LCRYPTO_USED(X509_PURPOSE_cleanup);
+LCRYPTO_USED(X509_PURPOSE_get_id);
+LCRYPTO_USED(X509_get_extension_flags);
+LCRYPTO_USED(X509_get_key_usage);
+LCRYPTO_USED(X509_get_extended_key_usage);
+LCRYPTO_USED(X509_get1_email);
+LCRYPTO_USED(X509_REQ_get1_email);
+LCRYPTO_USED(X509_email_free);
+LCRYPTO_USED(X509_get1_ocsp);
+LCRYPTO_USED(X509_check_host);
+LCRYPTO_USED(X509_check_email);
+LCRYPTO_USED(X509_check_ip);
+LCRYPTO_USED(X509_check_ip_asc);
+LCRYPTO_USED(a2i_IPADDRESS);
+LCRYPTO_USED(a2i_IPADDRESS_NC);
+LCRYPTO_USED(a2i_ipadd);
+LCRYPTO_USED(X509V3_NAME_from_section);
+LCRYPTO_USED(X509_POLICY_NODE_print);
+LCRYPTO_USED(ASRange_new);
+LCRYPTO_USED(ASRange_free);
+LCRYPTO_USED(d2i_ASRange);
+LCRYPTO_USED(i2d_ASRange);
+LCRYPTO_USED(ASIdOrRange_new);
+LCRYPTO_USED(ASIdOrRange_free);
+LCRYPTO_USED(d2i_ASIdOrRange);
+LCRYPTO_USED(i2d_ASIdOrRange);
+LCRYPTO_USED(ASIdentifierChoice_new);
+LCRYPTO_USED(ASIdentifierChoice_free);
+LCRYPTO_USED(d2i_ASIdentifierChoice);
+LCRYPTO_USED(i2d_ASIdentifierChoice);
+LCRYPTO_USED(ASIdentifiers_new);
+LCRYPTO_USED(ASIdentifiers_free);
+LCRYPTO_USED(d2i_ASIdentifiers);
+LCRYPTO_USED(i2d_ASIdentifiers);
+LCRYPTO_USED(IPAddressRange_new);
+LCRYPTO_USED(IPAddressRange_free);
+LCRYPTO_USED(d2i_IPAddressRange);
+LCRYPTO_USED(i2d_IPAddressRange);
+LCRYPTO_USED(IPAddressOrRange_new);
+LCRYPTO_USED(IPAddressOrRange_free);
+LCRYPTO_USED(d2i_IPAddressOrRange);
+LCRYPTO_USED(i2d_IPAddressOrRange);
+LCRYPTO_USED(IPAddressChoice_new);
+LCRYPTO_USED(IPAddressChoice_free);
+LCRYPTO_USED(d2i_IPAddressChoice);
+LCRYPTO_USED(i2d_IPAddressChoice);
+LCRYPTO_USED(IPAddressFamily_new);
+LCRYPTO_USED(IPAddressFamily_free);
+LCRYPTO_USED(d2i_IPAddressFamily);
+LCRYPTO_USED(i2d_IPAddressFamily);
+LCRYPTO_USED(X509v3_asid_add_inherit);
+LCRYPTO_USED(X509v3_asid_add_id_or_range);
+LCRYPTO_USED(X509v3_addr_add_inherit);
+LCRYPTO_USED(X509v3_addr_add_prefix);
+LCRYPTO_USED(X509v3_addr_add_range);
+LCRYPTO_USED(X509v3_addr_get_afi);
+LCRYPTO_USED(X509v3_addr_get_range);
+LCRYPTO_USED(X509v3_asid_is_canonical);
+LCRYPTO_USED(X509v3_addr_is_canonical);
+LCRYPTO_USED(X509v3_asid_canonize);
+LCRYPTO_USED(X509v3_addr_canonize);
+LCRYPTO_USED(X509v3_asid_inherits);
+LCRYPTO_USED(X509v3_addr_inherits);
+LCRYPTO_USED(X509v3_asid_subset);
+LCRYPTO_USED(X509v3_addr_subset);
+LCRYPTO_USED(X509v3_asid_validate_path);
+LCRYPTO_USED(X509v3_addr_validate_path);
+LCRYPTO_USED(X509v3_asid_validate_resource_set);
+LCRYPTO_USED(X509v3_addr_validate_resource_set);
+LCRYPTO_USED(ERR_load_X509V3_strings);
+#endif /* _LIBCRYPTO_X509V3_H */
diff --git a/src/lib/libcrypto/x509/by_dir.c b/src/lib/libcrypto/x509/by_dir.c
index fa05f552f9..2875a12c92 100644
--- a/src/lib/libcrypto/x509/by_dir.c
+++ b/src/lib/libcrypto/x509/by_dir.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: by_dir.c,v 1.41 2021/11/10 14:34:21 schwarze Exp $ */
+/* $OpenBSD: by_dir.c,v 1.42 2022/11/14 17:48:49 beck Exp $ */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
 * All rights reserved.
 *
@@ -117,6 +117,7 @@ X509_LOOKUP_hash_dir(void)
 {
        return &x509_dir_lookup;
 }
+LCRYPTO_ALIAS(X509_LOOKUP_hash_dir)
 static int
 dir_ctrl(X509_LOOKUP *ctx, int cmd, const char *argp, long argl,
diff --git a/src/lib/libcrypto/x509/by_file.c b/src/lib/libcrypto/x509/by_file.c
index 3116b7cf1e..747252d25b 100644
--- a/src/lib/libcrypto/x509/by_file.c
+++ b/src/lib/libcrypto/x509/by_file.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: by_file.c,v 1.25 2021/11/10 13:57:42 schwarze Exp $ */
+/* $OpenBSD: by_file.c,v 1.26 2022/11/14 17:48:49 beck Exp $ */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
 * All rights reserved.
 *
@@ -89,6 +89,7 @@ X509_LOOKUP_file(void)
 {
        return &x509_file_lookup;
 }
+LCRYPTO_ALIAS(X509_LOOKUP_file)
 static int
 by_file_ctrl(X509_LOOKUP *ctx, int cmd, const char *argp, long argl,
@@ -173,6 +174,7 @@ err:
        BIO_free(in);
        return ret;
 }
+LCRYPTO_ALIAS(X509_load_cert_file)
 int
 X509_load_crl_file(X509_LOOKUP *ctx, const char *file, int type)
@@ -229,6 +231,7 @@ err:
        BIO_free(in);
        return ret;
 }
+LCRYPTO_ALIAS(X509_load_crl_file)
 int
 X509_load_cert_crl_file(X509_LOOKUP *ctx, const char *file, int type)
@@ -267,4 +270,4 @@ X509_load_cert_crl_file(X509_LOOKUP *ctx, const char *file, int type)
        sk_X509_INFO_pop_free(inf, X509_INFO_free);
        return count;
 }
+LCRYPTO_ALIAS(X509_load_cert_crl_file)
diff --git a/src/lib/libcrypto/x509/by_mem.c b/src/lib/libcrypto/x509/by_mem.c
index 272877f843..fe1ac24525 100644
--- a/src/lib/libcrypto/x509/by_mem.c
+++ b/src/lib/libcrypto/x509/by_mem.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: by_mem.c,v 1.5 2021/11/01 20:53:08 tb Exp $ */
+/* $OpenBSD: by_mem.c,v 1.6 2022/11/14 17:48:49 beck Exp $ */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
 * All rights reserved.
 *
@@ -90,6 +90,7 @@ X509_LOOKUP_mem(void)
 {
        return (&x509_mem_lookup);
 }
+LCRYPTO_ALIAS(X509_LOOKUP_mem)
 static int
 by_mem_ctrl(X509_LOOKUP *lu, int cmd, const char *buf,
diff --git a/src/lib/libcrypto/x509/pcy_lib.c b/src/lib/libcrypto/x509/pcy_lib.c
index 3d5c58d710..e4b06e988b 100644
--- a/src/lib/libcrypto/x509/pcy_lib.c
+++ b/src/lib/libcrypto/x509/pcy_lib.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: pcy_lib.c,v 1.1 2020/06/04 15:19:31 jsing Exp $ */
+/* $OpenBSD: pcy_lib.c,v 1.2 2022/11/14 17:48:49 beck Exp $ */
 /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
 * project 2004.
 */
@@ -72,6 +72,7 @@ X509_policy_tree_level_count(const X509_POLICY_TREE *tree)
                return 0;
        return tree->nlevel;
 }
+LCRYPTO_ALIAS(X509_policy_tree_level_count)
 X509_POLICY_LEVEL *
 X509_policy_tree_get0_level(const X509_POLICY_TREE *tree, int i)
@@ -80,6 +81,7 @@ X509_policy_tree_get0_level(const X509_POLICY_TREE *tree, int i)
                return NULL;
        return tree->levels + i;
 }
+LCRYPTO_ALIAS(X509_policy_tree_get0_level)
 STACK_OF(X509_POLICY_NODE) *
 X509_policy_tree_get0_policies(const X509_POLICY_TREE *tree)
@@ -88,6 +90,7 @@ X509_policy_tree_get0_policies(const X509_POLICY_TREE *tree)
                return NULL;
        return tree->auth_policies;
 }
+LCRYPTO_ALIAS(X509_policy_tree_get0_policies)
 STACK_OF(X509_POLICY_NODE) *
 X509_policy_tree_get0_user_policies(const X509_POLICY_TREE *tree)
@@ -99,6 +102,7 @@ X509_policy_tree_get0_user_policies(const X509_POLICY_TREE *tree)
        else
                return tree->user_policies;
 }
+LCRYPTO_ALIAS(X509_policy_tree_get0_user_policies)
 /* X509_POLICY_LEVEL stuff */
@@ -116,6 +120,7 @@ X509_policy_level_node_count(X509_POLICY_LEVEL *level)
                n += sk_X509_POLICY_NODE_num(level->nodes);
        return n;
 }
+LCRYPTO_ALIAS(X509_policy_level_node_count)
 X509_POLICY_NODE *
 X509_policy_level_get0_node(X509_POLICY_LEVEL *level, int i)
@@ -129,6 +134,7 @@ X509_policy_level_get0_node(X509_POLICY_LEVEL *level, int i)
        }
        return sk_X509_POLICY_NODE_value(level->nodes, i);
 }
+LCRYPTO_ALIAS(X509_policy_level_get0_node)
 /* X509_POLICY_NODE stuff */
@@ -139,6 +145,7 @@ X509_policy_node_get0_policy(const X509_POLICY_NODE *node)
                return NULL;
        return node->data->valid_policy;
 }
+LCRYPTO_ALIAS(X509_policy_node_get0_policy)
 STACK_OF(POLICYQUALINFO) *
 X509_policy_node_get0_qualifiers(const X509_POLICY_NODE *node)
@@ -147,6 +154,7 @@ X509_policy_node_get0_qualifiers(const X509_POLICY_NODE *node)
                return NULL;
        return node->data->qualifier_set;
 }
+LCRYPTO_ALIAS(X509_policy_node_get0_qualifiers)
 const X509_POLICY_NODE *
 X509_policy_node_get0_parent(const X509_POLICY_NODE *node)
@@ -155,3 +163,4 @@ X509_policy_node_get0_parent(const X509_POLICY_NODE *node)
                return NULL;
        return node->parent;
 }
+LCRYPTO_ALIAS(X509_policy_node_get0_parent)
diff --git a/src/lib/libcrypto/x509/pcy_tree.c b/src/lib/libcrypto/x509/pcy_tree.c
index 284c08e66a..1df37c8776 100644
--- a/src/lib/libcrypto/x509/pcy_tree.c
+++ b/src/lib/libcrypto/x509/pcy_tree.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: pcy_tree.c,v 1.2 2021/11/01 20:53:08 tb Exp $ */
+/* $OpenBSD: pcy_tree.c,v 1.3 2022/11/14 17:48:49 beck Exp $ */
 /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
 * project 2004.
 */
@@ -657,6 +657,7 @@ X509_policy_tree_free(X509_POLICY_TREE *tree)
        free(tree->levels);
        free(tree);
 }
+LCRYPTO_ALIAS(X509_policy_tree_free)
 /* Application policy checking function.
 * Return codes:
@@ -769,3 +770,4 @@ error:
        return 0;
 }
+LCRYPTO_ALIAS(X509_policy_check)
diff --git a/src/lib/libcrypto/x509/x509_addr.c b/src/lib/libcrypto/x509/x509_addr.c
index e15bf821da..ee4e285a77 100644
--- a/src/lib/libcrypto/x509/x509_addr.c
+++ b/src/lib/libcrypto/x509/x509_addr.c
@@ -1,4 +1,4 @@
-/*      $OpenBSD: x509_addr.c,v 1.83 2022/05/25 17:10:30 tb Exp $ */
+/*      $OpenBSD: x509_addr.c,v 1.84 2022/11/14 17:48:49 beck Exp $ */
 /*
 * Contributed to the OpenSSL Project by the American Registry for
 * Internet Numbers ("ARIN").
@@ -215,24 +215,28 @@ d2i_IPAddressRange(IPAddressRange **a, const unsigned char **in, long len)
        return (IPAddressRange *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
            &IPAddressRange_it);
 }
+LCRYPTO_ALIAS(d2i_IPAddressRange)
 int
 i2d_IPAddressRange(IPAddressRange *a, unsigned char **out)
 {
        return ASN1_item_i2d((ASN1_VALUE *)a, out, &IPAddressRange_it);
 }
+LCRYPTO_ALIAS(i2d_IPAddressRange)
 IPAddressRange *
 IPAddressRange_new(void)
 {
        return (IPAddressRange *)ASN1_item_new(&IPAddressRange_it);
 }
+LCRYPTO_ALIAS(IPAddressRange_new)
 void
 IPAddressRange_free(IPAddressRange *a)
 {
        ASN1_item_free((ASN1_VALUE *)a, &IPAddressRange_it);
 }
+LCRYPTO_ALIAS(IPAddressRange_free)
 IPAddressOrRange *
 d2i_IPAddressOrRange(IPAddressOrRange **a, const unsigned char **in, long len)
@@ -240,24 +244,28 @@ d2i_IPAddressOrRange(IPAddressOrRange **a, const unsigned char **in, long len)
        return (IPAddressOrRange *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
            &IPAddressOrRange_it);
 }
+LCRYPTO_ALIAS(d2i_IPAddressOrRange)
 int
 i2d_IPAddressOrRange(IPAddressOrRange *a, unsigned char **out)
 {
        return ASN1_item_i2d((ASN1_VALUE *)a, out, &IPAddressOrRange_it);
 }
+LCRYPTO_ALIAS(i2d_IPAddressOrRange)
 IPAddressOrRange *
 IPAddressOrRange_new(void)
 {
        return (IPAddressOrRange *)ASN1_item_new(&IPAddressOrRange_it);
 }
+LCRYPTO_ALIAS(IPAddressOrRange_new)
 void
 IPAddressOrRange_free(IPAddressOrRange *a)
 {
        ASN1_item_free((ASN1_VALUE *)a, &IPAddressOrRange_it);
 }
+LCRYPTO_ALIAS(IPAddressOrRange_free)
 IPAddressChoice *
 d2i_IPAddressChoice(IPAddressChoice **a, const unsigned char **in, long len)
@@ -265,24 +273,28 @@ d2i_IPAddressChoice(IPAddressChoice **a, const unsigned char **in, long len)
        return (IPAddressChoice *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
            &IPAddressChoice_it);
 }
+LCRYPTO_ALIAS(d2i_IPAddressChoice)
 int
 i2d_IPAddressChoice(IPAddressChoice *a, unsigned char **out)
 {
        return ASN1_item_i2d((ASN1_VALUE *)a, out, &IPAddressChoice_it);
 }
+LCRYPTO_ALIAS(i2d_IPAddressChoice)
 IPAddressChoice *
 IPAddressChoice_new(void)
 {
        return (IPAddressChoice *)ASN1_item_new(&IPAddressChoice_it);
 }
+LCRYPTO_ALIAS(IPAddressChoice_new)
 void
 IPAddressChoice_free(IPAddressChoice *a)
 {
        ASN1_item_free((ASN1_VALUE *)a, &IPAddressChoice_it);
 }
+LCRYPTO_ALIAS(IPAddressChoice_free)
 IPAddressFamily *
 d2i_IPAddressFamily(IPAddressFamily **a, const unsigned char **in, long len)
@@ -290,24 +302,28 @@ d2i_IPAddressFamily(IPAddressFamily **a, const unsigned char **in, long len)
        return (IPAddressFamily *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
            &IPAddressFamily_it);
 }
+LCRYPTO_ALIAS(d2i_IPAddressFamily)
 int
 i2d_IPAddressFamily(IPAddressFamily *a, unsigned char **out)
 {
        return ASN1_item_i2d((ASN1_VALUE *)a, out, &IPAddressFamily_it);
 }
+LCRYPTO_ALIAS(i2d_IPAddressFamily)
 IPAddressFamily *
 IPAddressFamily_new(void)
 {
        return (IPAddressFamily *)ASN1_item_new(&IPAddressFamily_it);
 }
+LCRYPTO_ALIAS(IPAddressFamily_new)
 void
 IPAddressFamily_free(IPAddressFamily *a)
 {
        ASN1_item_free((ASN1_VALUE *)a, &IPAddressFamily_it);
 }
+LCRYPTO_ALIAS(IPAddressFamily_free)
 /*
 * Convenience accessors for IPAddressFamily.
@@ -518,6 +534,7 @@ X509v3_addr_get_afi(const IPAddressFamily *af)
        return afi;
 }
+LCRYPTO_ALIAS(X509v3_addr_get_afi)
 /*
 * Expand the bitstring form (RFC 3779, section 2.1.2) of an address into
@@ -1093,6 +1110,7 @@ X509v3_addr_add_inherit(IPAddrBlocks *addr, const unsigned afi,
        return IPAddressFamily_set_inheritance(af);
 }
+LCRYPTO_ALIAS(X509v3_addr_add_inherit)
 /*
 * Construct an IPAddressOrRange sequence, or return an existing one.
@@ -1156,6 +1174,7 @@ X509v3_addr_add_prefix(IPAddrBlocks *addr, const unsigned afi,
        return 1;
 }
+LCRYPTO_ALIAS(X509v3_addr_add_prefix)
 /*
 * Add a range.
@@ -1183,6 +1202,7 @@ X509v3_addr_add_range(IPAddrBlocks *addr, const unsigned afi,
        return 1;
 }
+LCRYPTO_ALIAS(X509v3_addr_add_range)
 static int
 extract_min_max_bitstr(IPAddressOrRange *aor, ASN1_BIT_STRING **out_min,
@@ -1242,6 +1262,7 @@ X509v3_addr_get_range(IPAddressOrRange *aor, const unsigned afi,
        return afi_len;
 }
+LCRYPTO_ALIAS(X509v3_addr_get_range)
 /*
 * Check whether an IPAddrBLocks is in canonical form.
@@ -1360,6 +1381,7 @@ X509v3_addr_is_canonical(IPAddrBlocks *addr)
         */
        return 1;
 }
+LCRYPTO_ALIAS(X509v3_addr_is_canonical)
 /*
 * Whack an IPAddressOrRanges into canonical form.
@@ -1466,6 +1488,7 @@ X509v3_addr_canonize(IPAddrBlocks *addr)
        return X509v3_addr_is_canonical(addr);
 }
+LCRYPTO_ALIAS(X509v3_addr_canonize)
 /*
 * v2i handler for the IPAddrBlocks extension.
@@ -1709,6 +1732,7 @@ X509v3_addr_inherits(IPAddrBlocks *addr)
        return 0;
 }
+LCRYPTO_ALIAS(X509v3_addr_inherits)
 /*
 * Figure out whether parent contains child.
@@ -1792,6 +1816,7 @@ X509v3_addr_subset(IPAddrBlocks *child, IPAddrBlocks *parent)
        }
        return 1;
 }
+LCRYPTO_ALIAS(X509v3_addr_subset)
 static int
 verify_error(X509_STORE_CTX *ctx, X509 *cert, int error, int depth)
@@ -1997,6 +2022,7 @@ X509v3_addr_validate_path(X509_STORE_CTX *ctx)
        }
        return addr_validate_path_internal(ctx, ctx->chain, NULL);
 }
+LCRYPTO_ALIAS(X509v3_addr_validate_path)
 /*
 * RFC 3779 2.3 path validation of an extension.
@@ -2014,5 +2040,6 @@ X509v3_addr_validate_resource_set(STACK_OF(X509) *chain, IPAddrBlocks *ext,
                return 0;
        return addr_validate_path_internal(NULL, chain, ext);
 }
+LCRYPTO_ALIAS(X509v3_addr_validate_resource_set)
 #endif /* OPENSSL_NO_RFC3779 */
diff --git a/src/lib/libcrypto/x509/x509_akeya.c b/src/lib/libcrypto/x509/x509_akeya.c
index aba8923caa..969cad1c3e 100644
--- a/src/lib/libcrypto/x509/x509_akeya.c
+++ b/src/lib/libcrypto/x509/x509_akeya.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: x509_akeya.c,v 1.1 2020/06/04 15:19:31 jsing Exp $ */
+/* $OpenBSD: x509_akeya.c,v 1.2 2022/11/14 17:48:50 beck Exp $ */
 /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
 * project 1999.
 */
@@ -104,21 +104,25 @@ d2i_AUTHORITY_KEYID(AUTHORITY_KEYID **a, const unsigned char **in, long len)
        return (AUTHORITY_KEYID *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
            &AUTHORITY_KEYID_it);
 }
+LCRYPTO_ALIAS(d2i_AUTHORITY_KEYID)
 int
 i2d_AUTHORITY_KEYID(AUTHORITY_KEYID *a, unsigned char **out)
 {
        return ASN1_item_i2d((ASN1_VALUE *)a, out, &AUTHORITY_KEYID_it);
 }
+LCRYPTO_ALIAS(i2d_AUTHORITY_KEYID)
 AUTHORITY_KEYID *
 AUTHORITY_KEYID_new(void)
 {
        return (AUTHORITY_KEYID *)ASN1_item_new(&AUTHORITY_KEYID_it);
 }
+LCRYPTO_ALIAS(AUTHORITY_KEYID_new)
 void
 AUTHORITY_KEYID_free(AUTHORITY_KEYID *a)
 {
        ASN1_item_free((ASN1_VALUE *)a, &AUTHORITY_KEYID_it);
 }
+LCRYPTO_ALIAS(AUTHORITY_KEYID_free)
diff --git a/src/lib/libcrypto/x509/x509_alt.c b/src/lib/libcrypto/x509/x509_alt.c
index cf8cbf0ce2..137a1c1c11 100644
--- a/src/lib/libcrypto/x509/x509_alt.c
+++ b/src/lib/libcrypto/x509/x509_alt.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: x509_alt.c,v 1.13 2022/11/11 12:02:34 beck Exp $ */
+/* $OpenBSD: x509_alt.c,v 1.14 2022/11/14 17:48:50 beck Exp $ */
 /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
 * project.
 */
@@ -152,6 +152,7 @@ i2v_GENERAL_NAMES(X509V3_EXT_METHOD *method, GENERAL_NAMES *gens,
        return NULL;
 }
+LCRYPTO_ALIAS(i2v_GENERAL_NAMES)
 STACK_OF(CONF_VALUE) *
 i2v_GENERAL_NAME(X509V3_EXT_METHOD *method, GENERAL_NAME *gen,
@@ -244,6 +245,7 @@ i2v_GENERAL_NAME(X509V3_EXT_METHOD *method, GENERAL_NAME *gen,
        return NULL;
 }
+LCRYPTO_ALIAS(i2v_GENERAL_NAME)
 int
 GENERAL_NAME_print(BIO *out, GENERAL_NAME *gen)
@@ -310,6 +312,7 @@ GENERAL_NAME_print(BIO *out, GENERAL_NAME *gen)
        }
        return 1;
 }
+LCRYPTO_ALIAS(GENERAL_NAME_print)
 static GENERAL_NAMES *
 v2i_issuer_alt(X509V3_EXT_METHOD *method, X509V3_CTX *ctx,
@@ -512,6 +515,7 @@ err:
        sk_GENERAL_NAME_pop_free(gens, GENERAL_NAME_free);
        return NULL;
 }
+LCRYPTO_ALIAS(v2i_GENERAL_NAMES)
 GENERAL_NAME *
 v2i_GENERAL_NAME(const X509V3_EXT_METHOD *method, X509V3_CTX *ctx,
@@ -519,6 +523,7 @@ v2i_GENERAL_NAME(const X509V3_EXT_METHOD *method, X509V3_CTX *ctx,
 {
        return v2i_GENERAL_NAME_ex(NULL, method, ctx, cnf, 0);
 }
+LCRYPTO_ALIAS(v2i_GENERAL_NAME)
 GENERAL_NAME *
 a2i_GENERAL_NAME(GENERAL_NAME *out, const X509V3_EXT_METHOD *method,
@@ -609,6 +614,7 @@ err:
                GENERAL_NAME_free(gen);
        return NULL;
 }
+LCRYPTO_ALIAS(a2i_GENERAL_NAME)
 GENERAL_NAME *
 v2i_GENERAL_NAME_ex(GENERAL_NAME *out, const X509V3_EXT_METHOD *method,
@@ -712,6 +718,7 @@ v2i_GENERAL_NAME_ex(GENERAL_NAME *out, const X509V3_EXT_METHOD *method,
                GENERAL_NAME_free(ret);
        return NULL;
 }
+LCRYPTO_ALIAS(v2i_GENERAL_NAME_ex)
 static int
 do_othername(GENERAL_NAME *gen, const char *value, X509V3_CTX *ctx)
diff --git a/src/lib/libcrypto/x509/x509_asid.c b/src/lib/libcrypto/x509/x509_asid.c
index e9db8bdabd..c95816da04 100644
--- a/src/lib/libcrypto/x509/x509_asid.c
+++ b/src/lib/libcrypto/x509/x509_asid.c
@@ -1,4 +1,4 @@
-/*      $OpenBSD: x509_asid.c,v 1.36 2022/11/13 23:38:42 tb Exp $ */
+/*      $OpenBSD: x509_asid.c,v 1.37 2022/11/14 17:48:50 beck Exp $ */
 /*
 * Contributed to the OpenSSL Project by the American Registry for
 * Internet Numbers ("ARIN").
@@ -191,24 +191,28 @@ d2i_ASRange(ASRange **a, const unsigned char **in, long len)
        return (ASRange *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
            &ASRange_it);
 }
+LCRYPTO_ALIAS(d2i_ASRange)
 int
 i2d_ASRange(ASRange *a, unsigned char **out)
 {
        return ASN1_item_i2d((ASN1_VALUE *)a, out, &ASRange_it);
 }
+LCRYPTO_ALIAS(i2d_ASRange)
 ASRange *
 ASRange_new(void)
 {
        return (ASRange *)ASN1_item_new(&ASRange_it);
 }
+LCRYPTO_ALIAS(ASRange_new)
 void
 ASRange_free(ASRange *a)
 {
        ASN1_item_free((ASN1_VALUE *)a, &ASRange_it);
 }
+LCRYPTO_ALIAS(ASRange_free)
 ASIdOrRange *
 d2i_ASIdOrRange(ASIdOrRange **a, const unsigned char **in, long len)
@@ -216,24 +220,28 @@ d2i_ASIdOrRange(ASIdOrRange **a, const unsigned char **in, long len)
        return (ASIdOrRange *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
            &ASIdOrRange_it);
 }
+LCRYPTO_ALIAS(d2i_ASIdOrRange)
 int
 i2d_ASIdOrRange(ASIdOrRange *a, unsigned char **out)
 {
        return ASN1_item_i2d((ASN1_VALUE *)a, out, &ASIdOrRange_it);
 }
+LCRYPTO_ALIAS(i2d_ASIdOrRange)
 ASIdOrRange *
 ASIdOrRange_new(void)
 {
        return (ASIdOrRange *)ASN1_item_new(&ASIdOrRange_it);
 }
+LCRYPTO_ALIAS(ASIdOrRange_new)
 void
 ASIdOrRange_free(ASIdOrRange *a)
 {
        ASN1_item_free((ASN1_VALUE *)a, &ASIdOrRange_it);
 }
+LCRYPTO_ALIAS(ASIdOrRange_free)
 ASIdentifierChoice *
 d2i_ASIdentifierChoice(ASIdentifierChoice **a, const unsigned char **in,
@@ -242,24 +250,28 @@ d2i_ASIdentifierChoice(ASIdentifierChoice **a, const unsigned char **in,
        return (ASIdentifierChoice *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
            &ASIdentifierChoice_it);
 }
+LCRYPTO_ALIAS(d2i_ASIdentifierChoice)
 int
 i2d_ASIdentifierChoice(ASIdentifierChoice *a, unsigned char **out)
 {
        return ASN1_item_i2d((ASN1_VALUE *)a, out, &ASIdentifierChoice_it);
 }
+LCRYPTO_ALIAS(i2d_ASIdentifierChoice)
 ASIdentifierChoice *
 ASIdentifierChoice_new(void)
 {
        return (ASIdentifierChoice *)ASN1_item_new(&ASIdentifierChoice_it);
 }
+LCRYPTO_ALIAS(ASIdentifierChoice_new)
 void
 ASIdentifierChoice_free(ASIdentifierChoice *a)
 {
        ASN1_item_free((ASN1_VALUE *)a, &ASIdentifierChoice_it);
 }
+LCRYPTO_ALIAS(ASIdentifierChoice_free)
 ASIdentifiers *
 d2i_ASIdentifiers(ASIdentifiers **a, const unsigned char **in, long len)
@@ -267,24 +279,28 @@ d2i_ASIdentifiers(ASIdentifiers **a, const unsigned char **in, long len)
        return (ASIdentifiers *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
            &ASIdentifiers_it);
 }
+LCRYPTO_ALIAS(d2i_ASIdentifiers)
 int
 i2d_ASIdentifiers(ASIdentifiers *a, unsigned char **out)
 {
        return ASN1_item_i2d((ASN1_VALUE *)a, out, &ASIdentifiers_it);
 }
+LCRYPTO_ALIAS(i2d_ASIdentifiers)
 ASIdentifiers *
 ASIdentifiers_new(void)
 {
        return (ASIdentifiers *)ASN1_item_new(&ASIdentifiers_it);
 }
+LCRYPTO_ALIAS(ASIdentifiers_new)
 void
 ASIdentifiers_free(ASIdentifiers *a)
 {
        ASN1_item_free((ASN1_VALUE *)a, &ASIdentifiers_it);
 }
+LCRYPTO_ALIAS(ASIdentifiers_free)
 /*
 * i2r method for an ASIdentifierChoice.
@@ -412,6 +428,7 @@ X509v3_asid_add_inherit(ASIdentifiers *asid, int which)
        }
        return (*choice)->type == ASIdentifierChoice_inherit;
 }
+LCRYPTO_ALIAS(X509v3_asid_add_inherit)
 /*
 * Add an ID or range to an ASIdentifierChoice.
@@ -466,6 +483,7 @@ X509v3_asid_add_id_or_range(ASIdentifiers *asid, int which, ASN1_INTEGER *min,
        ASIdOrRange_free(aor);
        return 0;
 }
+LCRYPTO_ALIAS(X509v3_asid_add_id_or_range)
 /*
 * Extract min and max values from an ASIdOrRange.
@@ -594,6 +612,7 @@ X509v3_asid_is_canonical(ASIdentifiers *asid)
            (ASIdentifierChoice_is_canonical(asid->asnum) &&
             ASIdentifierChoice_is_canonical(asid->rdi)));
 }
+LCRYPTO_ALIAS(X509v3_asid_is_canonical)
 /*
 * Whack an ASIdentifierChoice into canonical form.
@@ -761,6 +780,7 @@ X509v3_asid_canonize(ASIdentifiers *asid)
        return ASIdentifierChoice_canonize(asid->rdi);
 }
+LCRYPTO_ALIAS(X509v3_asid_canonize)
 /*
 * v2i method for an ASIdentifier extension.
@@ -919,6 +939,7 @@ X509v3_asid_inherits(ASIdentifiers *asid)
        return 0;
 }
+LCRYPTO_ALIAS(X509v3_asid_inherits)
 /*
 * Figure out whether parent contains child.
@@ -992,6 +1013,7 @@ X509v3_asid_subset(ASIdentifiers *child, ASIdentifiers *parent)
        return 1;
 }
+LCRYPTO_ALIAS(X509v3_asid_subset)
 /*
 * Validation error handling via callback.
@@ -1159,6 +1181,7 @@ X509v3_asid_validate_path(X509_STORE_CTX *ctx)
        }
        return asid_validate_path_internal(ctx, ctx->chain, NULL);
 }
+LCRYPTO_ALIAS(X509v3_asid_validate_path)
 /*
 * RFC 3779 3.3 path validation of an extension.
@@ -1176,5 +1199,6 @@ X509v3_asid_validate_resource_set(STACK_OF(X509) *chain, ASIdentifiers *ext,
                return 0;
        return asid_validate_path_internal(NULL, chain, ext);
 }
+LCRYPTO_ALIAS(X509v3_asid_validate_resource_set)
 #endif                          /* OPENSSL_NO_RFC3779 */
diff --git a/src/lib/libcrypto/x509/x509_att.c b/src/lib/libcrypto/x509/x509_att.c
index 8d369df900..bff412173b 100644
--- a/src/lib/libcrypto/x509/x509_att.c
+++ b/src/lib/libcrypto/x509/x509_att.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: x509_att.c,v 1.19 2022/05/09 19:19:33 jsing Exp $ */
+/* $OpenBSD: x509_att.c,v 1.20 2022/11/14 17:48:50 beck Exp $ */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
 * All rights reserved.
 *
@@ -73,6 +73,7 @@ X509at_get_attr_count(const STACK_OF(X509_ATTRIBUTE) *x)
 {
        return sk_X509_ATTRIBUTE_num(x);
 }
+LCRYPTO_ALIAS(X509at_get_attr_count)
 int
 X509at_get_attr_by_NID(const STACK_OF(X509_ATTRIBUTE) *x, int nid, int lastpos)
@@ -84,6 +85,7 @@ X509at_get_attr_by_NID(const STACK_OF(X509_ATTRIBUTE) *x, int nid, int lastpos)
                return (-2);
        return (X509at_get_attr_by_OBJ(x, obj, lastpos));
 }
+LCRYPTO_ALIAS(X509at_get_attr_by_NID)
 int
 X509at_get_attr_by_OBJ(const STACK_OF(X509_ATTRIBUTE) *sk,
@@ -105,6 +107,7 @@ X509at_get_attr_by_OBJ(const STACK_OF(X509_ATTRIBUTE) *sk,
        }
        return (-1);
 }
+LCRYPTO_ALIAS(X509at_get_attr_by_OBJ)
 X509_ATTRIBUTE *
 X509at_get_attr(const STACK_OF(X509_ATTRIBUTE) *x, int loc)
@@ -114,6 +117,7 @@ X509at_get_attr(const STACK_OF(X509_ATTRIBUTE) *x, int loc)
        else
                return sk_X509_ATTRIBUTE_value(x, loc);
 }
+LCRYPTO_ALIAS(X509at_get_attr)
 X509_ATTRIBUTE *
 X509at_delete_attr(STACK_OF(X509_ATTRIBUTE) *x, int loc)
@@ -125,6 +129,7 @@ X509at_delete_attr(STACK_OF(X509_ATTRIBUTE) *x, int loc)
        ret = sk_X509_ATTRIBUTE_delete(x, loc);
        return (ret);
 }
+LCRYPTO_ALIAS(X509at_delete_attr)
 STACK_OF(X509_ATTRIBUTE) *
 X509at_add1_attr(STACK_OF(X509_ATTRIBUTE) **x, X509_ATTRIBUTE *attr)
@@ -160,6 +165,7 @@ err2:
                sk_X509_ATTRIBUTE_free(sk);
        return (NULL);
 }
+LCRYPTO_ALIAS(X509at_add1_attr)
 STACK_OF(X509_ATTRIBUTE) *
 X509at_add1_attr_by_OBJ(STACK_OF(X509_ATTRIBUTE) **x, const ASN1_OBJECT *obj,
@@ -175,6 +181,7 @@ X509at_add1_attr_by_OBJ(STACK_OF(X509_ATTRIBUTE) **x, const ASN1_OBJECT *obj,
        X509_ATTRIBUTE_free(attr);
        return ret;
 }
+LCRYPTO_ALIAS(X509at_add1_attr_by_OBJ)
 STACK_OF(X509_ATTRIBUTE) *
 X509at_add1_attr_by_NID(STACK_OF(X509_ATTRIBUTE) **x, int nid, int type,
@@ -190,6 +197,7 @@ X509at_add1_attr_by_NID(STACK_OF(X509_ATTRIBUTE) **x, int nid, int type,
        X509_ATTRIBUTE_free(attr);
        return ret;
 }
+LCRYPTO_ALIAS(X509at_add1_attr_by_NID)
 STACK_OF(X509_ATTRIBUTE) *
 X509at_add1_attr_by_txt(STACK_OF(X509_ATTRIBUTE) **x, const char *attrname,
@@ -205,6 +213,7 @@ X509at_add1_attr_by_txt(STACK_OF(X509_ATTRIBUTE) **x, const char *attrname,
        X509_ATTRIBUTE_free(attr);
        return ret;
 }
+LCRYPTO_ALIAS(X509at_add1_attr_by_txt)
 void *
 X509at_get0_data_by_OBJ(STACK_OF(X509_ATTRIBUTE) *x, const ASN1_OBJECT *obj,
@@ -223,6 +232,7 @@ X509at_get0_data_by_OBJ(STACK_OF(X509_ATTRIBUTE) *x, const ASN1_OBJECT *obj,
                return NULL;
        return X509_ATTRIBUTE_get0_data(at, 0, type, NULL);
 }
+LCRYPTO_ALIAS(X509at_get0_data_by_OBJ)
 X509_ATTRIBUTE *
 X509_ATTRIBUTE_create_by_NID(X509_ATTRIBUTE **attr, int nid, int atrtype,
@@ -241,6 +251,7 @@ X509_ATTRIBUTE_create_by_NID(X509_ATTRIBUTE **attr, int nid, int atrtype,
                ASN1_OBJECT_free(obj);
        return (ret);
 }
+LCRYPTO_ALIAS(X509_ATTRIBUTE_create_by_NID)
 X509_ATTRIBUTE *
 X509_ATTRIBUTE_create_by_OBJ(X509_ATTRIBUTE **attr, const ASN1_OBJECT *obj,
@@ -270,6 +281,7 @@ err:
                X509_ATTRIBUTE_free(ret);
        return (NULL);
 }
+LCRYPTO_ALIAS(X509_ATTRIBUTE_create_by_OBJ)
 X509_ATTRIBUTE *
 X509_ATTRIBUTE_create_by_txt(X509_ATTRIBUTE **attr, const char *atrname,
@@ -288,6 +300,7 @@ X509_ATTRIBUTE_create_by_txt(X509_ATTRIBUTE **attr, const char *atrname,
        ASN1_OBJECT_free(obj);
        return nattr;
 }
+LCRYPTO_ALIAS(X509_ATTRIBUTE_create_by_txt)
 int
 X509_ATTRIBUTE_set1_object(X509_ATTRIBUTE *attr, const ASN1_OBJECT *obj)
@@ -298,6 +311,7 @@ X509_ATTRIBUTE_set1_object(X509_ATTRIBUTE *attr, const ASN1_OBJECT *obj)
        attr->object = OBJ_dup(obj);
        return attr->object != NULL;
 }
+LCRYPTO_ALIAS(X509_ATTRIBUTE_set1_object)
 int
 X509_ATTRIBUTE_set1_data(X509_ATTRIBUTE *attr, int attrtype, const void *data,
@@ -351,6 +365,7 @@ err:
        X509error(ERR_R_MALLOC_FAILURE);
        return 0;
 }
+LCRYPTO_ALIAS(X509_ATTRIBUTE_set1_data)
 int
 X509_ATTRIBUTE_count(const X509_ATTRIBUTE *attr)
@@ -360,6 +375,7 @@ X509_ATTRIBUTE_count(const X509_ATTRIBUTE *attr)
        return sk_ASN1_TYPE_num(attr->set);
 }
+LCRYPTO_ALIAS(X509_ATTRIBUTE_count)
 ASN1_OBJECT *
 X509_ATTRIBUTE_get0_object(X509_ATTRIBUTE *attr)
@@ -368,6 +384,7 @@ X509_ATTRIBUTE_get0_object(X509_ATTRIBUTE *attr)
                return (NULL);
        return (attr->object);
 }
+LCRYPTO_ALIAS(X509_ATTRIBUTE_get0_object)
 void *
 X509_ATTRIBUTE_get0_data(X509_ATTRIBUTE *attr, int idx, int atrtype, void *data)
@@ -383,6 +400,7 @@ X509_ATTRIBUTE_get0_data(X509_ATTRIBUTE *attr, int idx, int atrtype, void *data)
        }
        return ttmp->value.ptr;
 }
+LCRYPTO_ALIAS(X509_ATTRIBUTE_get0_data)
 ASN1_TYPE *
 X509_ATTRIBUTE_get0_type(X509_ATTRIBUTE *attr, int idx)
@@ -392,3 +410,4 @@ X509_ATTRIBUTE_get0_type(X509_ATTRIBUTE *attr, int idx)
        return sk_ASN1_TYPE_value(attr->set, idx);
 }
+LCRYPTO_ALIAS(X509_ATTRIBUTE_get0_type)
diff --git a/src/lib/libcrypto/x509/x509_bcons.c b/src/lib/libcrypto/x509/x509_bcons.c
index 48ce7d6087..8a9c1e419a 100644
--- a/src/lib/libcrypto/x509/x509_bcons.c
+++ b/src/lib/libcrypto/x509/x509_bcons.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: x509_bcons.c,v 1.1 2020/06/04 15:19:31 jsing Exp $ */
+/* $OpenBSD: x509_bcons.c,v 1.2 2022/11/14 17:48:50 beck Exp $ */
 /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
 * project 1999.
 */
@@ -121,24 +121,28 @@ d2i_BASIC_CONSTRAINTS(BASIC_CONSTRAINTS **a, const unsigned char **in, long len)
        return (BASIC_CONSTRAINTS *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
            &BASIC_CONSTRAINTS_it);
 }
+LCRYPTO_ALIAS(d2i_BASIC_CONSTRAINTS)
 int
 i2d_BASIC_CONSTRAINTS(BASIC_CONSTRAINTS *a, unsigned char **out)
 {
        return ASN1_item_i2d((ASN1_VALUE *)a, out, &BASIC_CONSTRAINTS_it);
 }
+LCRYPTO_ALIAS(i2d_BASIC_CONSTRAINTS)
 BASIC_CONSTRAINTS *
 BASIC_CONSTRAINTS_new(void)
 {
        return (BASIC_CONSTRAINTS *)ASN1_item_new(&BASIC_CONSTRAINTS_it);
 }
+LCRYPTO_ALIAS(BASIC_CONSTRAINTS_new)
 void
 BASIC_CONSTRAINTS_free(BASIC_CONSTRAINTS *a)
 {
        ASN1_item_free((ASN1_VALUE *)a, &BASIC_CONSTRAINTS_it);
 }
+LCRYPTO_ALIAS(BASIC_CONSTRAINTS_free)
 static STACK_OF(CONF_VALUE) *
diff --git a/src/lib/libcrypto/x509/x509_bitst.c b/src/lib/libcrypto/x509/x509_bitst.c
index 3d998188e8..bea089e31c 100644
--- a/src/lib/libcrypto/x509/x509_bitst.c
+++ b/src/lib/libcrypto/x509/x509_bitst.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: x509_bitst.c,v 1.1 2020/06/04 15:19:31 jsing Exp $ */
+/* $OpenBSD: x509_bitst.c,v 1.2 2022/11/14 17:48:50 beck Exp $ */
 /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
 * project 1999.
 */
@@ -148,6 +148,7 @@ i2v_ASN1_BIT_STRING(X509V3_EXT_METHOD *method, ASN1_BIT_STRING *bits,
        return NULL;
 }
+LCRYPTO_ALIAS(i2v_ASN1_BIT_STRING)
 ASN1_BIT_STRING *
 v2i_ASN1_BIT_STRING(X509V3_EXT_METHOD *method, X509V3_CTX *ctx,
@@ -185,3 +186,4 @@ v2i_ASN1_BIT_STRING(X509V3_EXT_METHOD *method, X509V3_CTX *ctx,
        }
        return bs;
 }
+LCRYPTO_ALIAS(v2i_ASN1_BIT_STRING)
diff --git a/src/lib/libcrypto/x509/x509_cmp.c b/src/lib/libcrypto/x509/x509_cmp.c
index 4fd8d78fc3..542ae76c17 100644
--- a/src/lib/libcrypto/x509/x509_cmp.c
+++ b/src/lib/libcrypto/x509/x509_cmp.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: x509_cmp.c,v 1.39 2022/02/24 22:05:06 beck Exp $ */
+/* $OpenBSD: x509_cmp.c,v 1.40 2022/11/14 17:48:50 beck Exp $ */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
 * All rights reserved.
 *
@@ -84,6 +84,7 @@ X509_issuer_and_serial_cmp(const X509 *a, const X509 *b)
                return (i);
        return (X509_NAME_cmp(ai->issuer, bi->issuer));
 }
+LCRYPTO_ALIAS(X509_issuer_and_serial_cmp)
 #ifndef OPENSSL_NO_MD5
 unsigned long
@@ -119,6 +120,7 @@ err:
        free(f);
        return (ret);
 }
+LCRYPTO_ALIAS(X509_issuer_and_serial_hash)
 #endif
 int
@@ -126,18 +128,21 @@ X509_issuer_name_cmp(const X509 *a, const X509 *b)
 {
        return (X509_NAME_cmp(a->cert_info->issuer, b->cert_info->issuer));
 }
+LCRYPTO_ALIAS(X509_issuer_name_cmp)
 int
 X509_subject_name_cmp(const X509 *a, const X509 *b)
 {
        return (X509_NAME_cmp(a->cert_info->subject, b->cert_info->subject));
 }
+LCRYPTO_ALIAS(X509_subject_name_cmp)
 int
 X509_CRL_cmp(const X509_CRL *a, const X509_CRL *b)
 {
        return (X509_NAME_cmp(a->crl->issuer, b->crl->issuer));
 }
+LCRYPTO_ALIAS(X509_CRL_cmp)
 #ifndef OPENSSL_NO_SHA
 int
@@ -145,6 +150,7 @@ X509_CRL_match(const X509_CRL *a, const X509_CRL *b)
 {
        return memcmp(a->hash, b->hash, X509_CRL_HASH_LEN);
 }
+LCRYPTO_ALIAS(X509_CRL_match)
 #endif
 X509_NAME *
@@ -152,12 +158,14 @@ X509_get_issuer_name(const X509 *a)
 {
        return (a->cert_info->issuer);
 }
+LCRYPTO_ALIAS(X509_get_issuer_name)
 unsigned long
 X509_issuer_name_hash(X509 *x)
 {
        return (X509_NAME_hash(x->cert_info->issuer));
 }
+LCRYPTO_ALIAS(X509_issuer_name_hash)
 #ifndef OPENSSL_NO_MD5
 unsigned long
@@ -165,6 +173,7 @@ X509_issuer_name_hash_old(X509 *x)
 {
        return (X509_NAME_hash_old(x->cert_info->issuer));
 }
+LCRYPTO_ALIAS(X509_issuer_name_hash_old)
 #endif
 X509_NAME *
@@ -172,24 +181,28 @@ X509_get_subject_name(const X509 *a)
 {
        return (a->cert_info->subject);
 }
+LCRYPTO_ALIAS(X509_get_subject_name)
 ASN1_INTEGER *
 X509_get_serialNumber(X509 *a)
 {
        return (a->cert_info->serialNumber);
 }
+LCRYPTO_ALIAS(X509_get_serialNumber)
 const ASN1_INTEGER *
 X509_get0_serialNumber(const X509 *a)
 {
        return (a->cert_info->serialNumber);
 }
+LCRYPTO_ALIAS(X509_get0_serialNumber)
 unsigned long
 X509_subject_name_hash(X509 *x)
 {
        return (X509_NAME_hash(x->cert_info->subject));
 }
+LCRYPTO_ALIAS(X509_subject_name_hash)
 #ifndef OPENSSL_NO_MD5
 unsigned long
@@ -197,6 +210,7 @@ X509_subject_name_hash_old(X509 *x)
 {
        return (X509_NAME_hash_old(x->cert_info->subject));
 }
+LCRYPTO_ALIAS(X509_subject_name_hash_old)
 #endif
 #ifndef OPENSSL_NO_SHA
@@ -218,6 +232,7 @@ X509_cmp(const X509 *a, const X509 *b)
        return memcmp(a->hash, b->hash, X509_CERT_HASH_LEN);
 }
+LCRYPTO_ALIAS(X509_cmp)
 #endif
 int
@@ -241,6 +256,7 @@ X509_NAME_cmp(const X509_NAME *a, const X509_NAME *b)
                return ret;
        return memcmp(a->canon_enc, b->canon_enc, a->canon_enclen);
 }
+LCRYPTO_ALIAS(X509_NAME_cmp)
 unsigned long
 X509_NAME_hash(X509_NAME *x)
@@ -259,6 +275,7 @@ X509_NAME_hash(X509_NAME *x)
            0xffffffffL;
        return (ret);
 }
+LCRYPTO_ALIAS(X509_NAME_hash)
 #ifndef OPENSSL_NO_MD5
@@ -287,6 +304,7 @@ X509_NAME_hash_old(X509_NAME *x)
        return (ret);
 }
+LCRYPTO_ALIAS(X509_NAME_hash_old)
 #endif
 /* Search a stack of X509 for a match */
@@ -312,6 +330,7 @@ X509_find_by_issuer_and_serial(STACK_OF(X509) *sk, X509_NAME *name,
        }
        return (NULL);
 }
+LCRYPTO_ALIAS(X509_find_by_issuer_and_serial)
 X509 *
 X509_find_by_subject(STACK_OF(X509) *sk, X509_NAME *name)
@@ -326,6 +345,7 @@ X509_find_by_subject(STACK_OF(X509) *sk, X509_NAME *name)
        }
        return (NULL);
 }
+LCRYPTO_ALIAS(X509_find_by_subject)
 EVP_PKEY *
 X509_get_pubkey(X509 *x)
@@ -334,6 +354,7 @@ X509_get_pubkey(X509 *x)
                return (NULL);
        return (X509_PUBKEY_get(x->cert_info->key));
 }
+LCRYPTO_ALIAS(X509_get_pubkey)
 EVP_PKEY *
 X509_get0_pubkey(const X509 *x)
@@ -342,6 +363,7 @@ X509_get0_pubkey(const X509 *x)
                return (NULL);
        return (X509_PUBKEY_get0(x->cert_info->key));
 }
+LCRYPTO_ALIAS(X509_get0_pubkey)
 ASN1_BIT_STRING *
 X509_get0_pubkey_bitstr(const X509 *x)
@@ -350,6 +372,7 @@ X509_get0_pubkey_bitstr(const X509 *x)
                return NULL;
        return x->cert_info->key->public_key;
 }
+LCRYPTO_ALIAS(X509_get0_pubkey_bitstr)
 int
 X509_check_private_key(const X509 *x, const EVP_PKEY *k)
@@ -380,6 +403,7 @@ X509_check_private_key(const X509 *x, const EVP_PKEY *k)
                return 1;
        return 0;
 }
+LCRYPTO_ALIAS(X509_check_private_key)
 /*
 * Not strictly speaking an "up_ref" as a STACK doesn't have a reference
@@ -398,3 +422,4 @@ X509_chain_up_ref(STACK_OF(X509) *chain)
        return ret;
 }
+LCRYPTO_ALIAS(X509_chain_up_ref)
diff --git a/src/lib/libcrypto/x509/x509_conf.c b/src/lib/libcrypto/x509/x509_conf.c
index cd703fc156..def1441f3f 100644
--- a/src/lib/libcrypto/x509/x509_conf.c
+++ b/src/lib/libcrypto/x509/x509_conf.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: x509_conf.c,v 1.2 2021/11/01 20:53:08 tb Exp $ */
+/* $OpenBSD: x509_conf.c,v 1.3 2022/11/14 17:48:50 beck Exp $ */
 /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
 * project 1999.
 */
@@ -104,6 +104,7 @@ X509V3_EXT_nconf(CONF *conf, X509V3_CTX *ctx, const char *name,
        }
        return ret;
 }
+LCRYPTO_ALIAS(X509V3_EXT_nconf)
 /* CONF *conf:  Config file    */
 /* char *value:  Value    */
@@ -120,6 +121,7 @@ X509V3_EXT_nconf_nid(CONF *conf, X509V3_CTX *ctx, int ext_nid,
                    value, crit, ext_type, ctx);
        return do_ext_nconf(conf, ctx, ext_nid, crit, value);
 }
+LCRYPTO_ALIAS(X509V3_EXT_nconf_nid)
 /* CONF *conf:  Config file    */
 /* char *value:  Value    */
@@ -238,6 +240,7 @@ X509V3_EXT_i2d(int ext_nid, int crit, void *ext_struc)
        }
        return do_ext_i2d(method, ext_nid, crit, ext_struc);
 }
+LCRYPTO_ALIAS(X509V3_EXT_i2d)
 /* Check the extension string for critical flag */
 static int
@@ -364,6 +367,7 @@ X509V3_EXT_add_nconf_sk(CONF *conf, X509V3_CTX *ctx, const char *section,
        }
        return 1;
 }
+LCRYPTO_ALIAS(X509V3_EXT_add_nconf_sk)
 /* Convenience functions to add extensions to a certificate, CRL and request */
@@ -377,6 +381,7 @@ X509V3_EXT_add_nconf(CONF *conf, X509V3_CTX *ctx, const char *section,
                sk = &cert->cert_info->extensions;
        return X509V3_EXT_add_nconf_sk(conf, ctx, section, sk);
 }
+LCRYPTO_ALIAS(X509V3_EXT_add_nconf)
 /* Same as above but for a CRL */
@@ -390,6 +395,7 @@ X509V3_EXT_CRL_add_nconf(CONF *conf, X509V3_CTX *ctx, const char *section,
                sk = &crl->crl->extensions;
        return X509V3_EXT_add_nconf_sk(conf, ctx, section, sk);
 }
+LCRYPTO_ALIAS(X509V3_EXT_CRL_add_nconf)
 /* Add extensions to certificate request */
@@ -409,6 +415,7 @@ X509V3_EXT_REQ_add_nconf(CONF *conf, X509V3_CTX *ctx, const char *section,
        sk_X509_EXTENSION_pop_free(extlist, X509_EXTENSION_free);
        return i;
 }
+LCRYPTO_ALIAS(X509V3_EXT_REQ_add_nconf)
 /* Config database functions */
@@ -421,6 +428,7 @@ X509V3_get_string(X509V3_CTX *ctx, const char *name, const char *section)
        }
        return ctx->db_meth->get_string(ctx->db, name, section);
 }
+LCRYPTO_ALIAS(X509V3_get_string)
 STACK_OF(CONF_VALUE) *
 X509V3_get_section(X509V3_CTX *ctx, const char *section)
@@ -431,6 +439,7 @@ X509V3_get_section(X509V3_CTX *ctx, const char *section)
        }
        return ctx->db_meth->get_section(ctx->db, section);
 }
+LCRYPTO_ALIAS(X509V3_get_section)
 void
 X509V3_string_free(X509V3_CTX *ctx, char *str)
@@ -440,6 +449,7 @@ X509V3_string_free(X509V3_CTX *ctx, char *str)
        if (ctx->db_meth->free_string)
                ctx->db_meth->free_string(ctx->db, str);
 }
+LCRYPTO_ALIAS(X509V3_string_free)
 void
 X509V3_section_free(X509V3_CTX *ctx, STACK_OF(CONF_VALUE) *section)
@@ -449,6 +459,7 @@ X509V3_section_free(X509V3_CTX *ctx, STACK_OF(CONF_VALUE) *section)
        if (ctx->db_meth->free_section)
                ctx->db_meth->free_section(ctx->db, section);
 }
+LCRYPTO_ALIAS(X509V3_section_free)
 static char *
 nconf_get_string(void *db, const char *section, const char *value)
@@ -475,6 +486,7 @@ X509V3_set_nconf(X509V3_CTX *ctx, CONF *conf)
        ctx->db_meth = &nconf_method;
        ctx->db = conf;
 }
+LCRYPTO_ALIAS(X509V3_set_nconf)
 void
 X509V3_set_ctx(X509V3_CTX *ctx, X509 *issuer, X509 *subj, X509_REQ *req,
@@ -486,6 +498,7 @@ X509V3_set_ctx(X509V3_CTX *ctx, X509 *issuer, X509 *subj, X509_REQ *req,
        ctx->subject_req = req;
        ctx->flags = flags;
 }
+LCRYPTO_ALIAS(X509V3_set_ctx)
 /* Old conf compatibility functions */
@@ -498,6 +511,7 @@ X509V3_EXT_conf(LHASH_OF(CONF_VALUE) *conf, X509V3_CTX *ctx, const char *name,
        CONF_set_nconf(&ctmp, conf);
        return X509V3_EXT_nconf(&ctmp, ctx, name, value);
 }
+LCRYPTO_ALIAS(X509V3_EXT_conf)
 /* LHASH *conf:  Config file    */
 /* char *value:  Value    */
@@ -510,6 +524,7 @@ X509V3_EXT_conf_nid(LHASH_OF(CONF_VALUE) *conf, X509V3_CTX *ctx, int ext_nid,
        CONF_set_nconf(&ctmp, conf);
        return X509V3_EXT_nconf_nid(&ctmp, ctx, ext_nid, value);
 }
+LCRYPTO_ALIAS(X509V3_EXT_conf_nid)
 static char *
 conf_lhash_get_string(void *db, const char *section, const char *value)
@@ -536,6 +551,7 @@ X509V3_set_conf_lhash(X509V3_CTX *ctx, LHASH_OF(CONF_VALUE) *lhash)
        ctx->db_meth = &conf_lhash_method;
        ctx->db = lhash;
 }
+LCRYPTO_ALIAS(X509V3_set_conf_lhash)
 int
 X509V3_EXT_add_conf(LHASH_OF(CONF_VALUE) *conf, X509V3_CTX *ctx,
@@ -546,6 +562,7 @@ X509V3_EXT_add_conf(LHASH_OF(CONF_VALUE) *conf, X509V3_CTX *ctx,
        CONF_set_nconf(&ctmp, conf);
        return X509V3_EXT_add_nconf(&ctmp, ctx, section, cert);
 }
+LCRYPTO_ALIAS(X509V3_EXT_add_conf)
 /* Same as above but for a CRL */
@@ -558,6 +575,7 @@ X509V3_EXT_CRL_add_conf(LHASH_OF(CONF_VALUE) *conf, X509V3_CTX *ctx,
        CONF_set_nconf(&ctmp, conf);
        return X509V3_EXT_CRL_add_nconf(&ctmp, ctx, section, crl);
 }
+LCRYPTO_ALIAS(X509V3_EXT_CRL_add_conf)
 /* Add extensions to certificate request */
@@ -570,3 +588,4 @@ X509V3_EXT_REQ_add_conf(LHASH_OF(CONF_VALUE) *conf, X509V3_CTX *ctx,
        CONF_set_nconf(&ctmp, conf);
        return X509V3_EXT_REQ_add_nconf(&ctmp, ctx, section, req);
 }
+LCRYPTO_ALIAS(X509V3_EXT_REQ_add_conf)
diff --git a/src/lib/libcrypto/x509/x509_cpols.c b/src/lib/libcrypto/x509/x509_cpols.c
index 93527a4366..8d50c0545a 100644
--- a/src/lib/libcrypto/x509/x509_cpols.c
+++ b/src/lib/libcrypto/x509/x509_cpols.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: x509_cpols.c,v 1.4 2022/01/14 08:16:13 tb Exp $ */
+/* $OpenBSD: x509_cpols.c,v 1.5 2022/11/14 17:48:50 beck Exp $ */
 /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
 * project 1999.
 */
@@ -125,24 +125,28 @@ d2i_CERTIFICATEPOLICIES(CERTIFICATEPOLICIES **a, const unsigned char **in, long
        return (CERTIFICATEPOLICIES *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
            &CERTIFICATEPOLICIES_it);
 }
+LCRYPTO_ALIAS(d2i_CERTIFICATEPOLICIES)
 int
 i2d_CERTIFICATEPOLICIES(CERTIFICATEPOLICIES *a, unsigned char **out)
 {
        return ASN1_item_i2d((ASN1_VALUE *)a, out, &CERTIFICATEPOLICIES_it);
 }
+LCRYPTO_ALIAS(i2d_CERTIFICATEPOLICIES)
 CERTIFICATEPOLICIES *
 CERTIFICATEPOLICIES_new(void)
 {
        return (CERTIFICATEPOLICIES *)ASN1_item_new(&CERTIFICATEPOLICIES_it);
 }
+LCRYPTO_ALIAS(CERTIFICATEPOLICIES_new)
 void
 CERTIFICATEPOLICIES_free(CERTIFICATEPOLICIES *a)
 {
        ASN1_item_free((ASN1_VALUE *)a, &CERTIFICATEPOLICIES_it);
 }
+LCRYPTO_ALIAS(CERTIFICATEPOLICIES_free)
 static const ASN1_TEMPLATE POLICYINFO_seq_tt[] = {
        {
@@ -178,24 +182,28 @@ d2i_POLICYINFO(POLICYINFO **a, const unsigned char **in, long len)
        return (POLICYINFO *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
            &POLICYINFO_it);
 }
+LCRYPTO_ALIAS(d2i_POLICYINFO)
 int
 i2d_POLICYINFO(POLICYINFO *a, unsigned char **out)
 {
        return ASN1_item_i2d((ASN1_VALUE *)a, out, &POLICYINFO_it);
 }
+LCRYPTO_ALIAS(i2d_POLICYINFO)
 POLICYINFO *
 POLICYINFO_new(void)
 {
        return (POLICYINFO *)ASN1_item_new(&POLICYINFO_it);
 }
+LCRYPTO_ALIAS(POLICYINFO_new)
 void
 POLICYINFO_free(POLICYINFO *a)
 {
        ASN1_item_free((ASN1_VALUE *)a, &POLICYINFO_it);
 }
+LCRYPTO_ALIAS(POLICYINFO_free)
 static const ASN1_TEMPLATE policydefault_tt = {
        .flags = 0,
@@ -273,24 +281,28 @@ d2i_POLICYQUALINFO(POLICYQUALINFO **a, const unsigned char **in, long len)
        return (POLICYQUALINFO *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
            &POLICYQUALINFO_it);
 }
+LCRYPTO_ALIAS(d2i_POLICYQUALINFO)
 int
 i2d_POLICYQUALINFO(POLICYQUALINFO *a, unsigned char **out)
 {
        return ASN1_item_i2d((ASN1_VALUE *)a, out, &POLICYQUALINFO_it);
 }
+LCRYPTO_ALIAS(i2d_POLICYQUALINFO)
 POLICYQUALINFO *
 POLICYQUALINFO_new(void)
 {
        return (POLICYQUALINFO *)ASN1_item_new(&POLICYQUALINFO_it);
 }
+LCRYPTO_ALIAS(POLICYQUALINFO_new)
 void
 POLICYQUALINFO_free(POLICYQUALINFO *a)
 {
        ASN1_item_free((ASN1_VALUE *)a, &POLICYQUALINFO_it);
 }
+LCRYPTO_ALIAS(POLICYQUALINFO_free)
 static const ASN1_TEMPLATE USERNOTICE_seq_tt[] = {
        {
@@ -326,24 +338,28 @@ d2i_USERNOTICE(USERNOTICE **a, const unsigned char **in, long len)
        return (USERNOTICE *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
            &USERNOTICE_it);
 }
+LCRYPTO_ALIAS(d2i_USERNOTICE)
 int
 i2d_USERNOTICE(USERNOTICE *a, unsigned char **out)
 {
        return ASN1_item_i2d((ASN1_VALUE *)a, out, &USERNOTICE_it);
 }
+LCRYPTO_ALIAS(i2d_USERNOTICE)
 USERNOTICE *
 USERNOTICE_new(void)
 {
        return (USERNOTICE *)ASN1_item_new(&USERNOTICE_it);
 }
+LCRYPTO_ALIAS(USERNOTICE_new)
 void
 USERNOTICE_free(USERNOTICE *a)
 {
        ASN1_item_free((ASN1_VALUE *)a, &USERNOTICE_it);
 }
+LCRYPTO_ALIAS(USERNOTICE_free)
 static const ASN1_TEMPLATE NOTICEREF_seq_tt[] = {
        {
@@ -379,24 +395,28 @@ d2i_NOTICEREF(NOTICEREF **a, const unsigned char **in, long len)
        return (NOTICEREF *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
            &NOTICEREF_it);
 }
+LCRYPTO_ALIAS(d2i_NOTICEREF)
 int
 i2d_NOTICEREF(NOTICEREF *a, unsigned char **out)
 {
        return ASN1_item_i2d((ASN1_VALUE *)a, out, &NOTICEREF_it);
 }
+LCRYPTO_ALIAS(i2d_NOTICEREF)
 NOTICEREF *
 NOTICEREF_new(void)
 {
        return (NOTICEREF *)ASN1_item_new(&NOTICEREF_it);
 }
+LCRYPTO_ALIAS(NOTICEREF_new)
 void
 NOTICEREF_free(NOTICEREF *a)
 {
        ASN1_item_free((ASN1_VALUE *)a, &NOTICEREF_it);
 }
+LCRYPTO_ALIAS(NOTICEREF_free)
 static STACK_OF(POLICYINFO) *
 r2i_certpol(X509V3_EXT_METHOD *method, X509V3_CTX *ctx, char *value)
@@ -762,3 +782,4 @@ X509_POLICY_NODE_print(BIO *out, X509_POLICY_NODE *node, int indent)
        else
                BIO_printf(out, "%*sNo Qualifiers\n", indent + 2, "");
 }
+LCRYPTO_ALIAS(X509_POLICY_NODE_print)
diff --git a/src/lib/libcrypto/x509/x509_crld.c b/src/lib/libcrypto/x509/x509_crld.c
index 6b6f795378..43150b21a9 100644
--- a/src/lib/libcrypto/x509/x509_crld.c
+++ b/src/lib/libcrypto/x509/x509_crld.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: x509_crld.c,v 1.2 2021/11/01 20:53:08 tb Exp $ */
+/* $OpenBSD: x509_crld.c,v 1.3 2022/11/14 17:48:50 beck Exp $ */
 /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
 * project 1999.
 */
@@ -426,24 +426,28 @@ d2i_DIST_POINT_NAME(DIST_POINT_NAME **a, const unsigned char **in, long len)
        return (DIST_POINT_NAME *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
            &DIST_POINT_NAME_it);
 }
+LCRYPTO_ALIAS(d2i_DIST_POINT_NAME)
 int
 i2d_DIST_POINT_NAME(DIST_POINT_NAME *a, unsigned char **out)
 {
        return ASN1_item_i2d((ASN1_VALUE *)a, out, &DIST_POINT_NAME_it);
 }
+LCRYPTO_ALIAS(i2d_DIST_POINT_NAME)
 DIST_POINT_NAME *
 DIST_POINT_NAME_new(void)
 {
        return (DIST_POINT_NAME *)ASN1_item_new(&DIST_POINT_NAME_it);
 }
+LCRYPTO_ALIAS(DIST_POINT_NAME_new)
 void
 DIST_POINT_NAME_free(DIST_POINT_NAME *a)
 {
        ASN1_item_free((ASN1_VALUE *)a, &DIST_POINT_NAME_it);
 }
+LCRYPTO_ALIAS(DIST_POINT_NAME_free)
 static const ASN1_TEMPLATE DIST_POINT_seq_tt[] = {
        {
@@ -486,24 +490,28 @@ d2i_DIST_POINT(DIST_POINT **a, const unsigned char **in, long len)
        return (DIST_POINT *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
            &DIST_POINT_it);
 }
+LCRYPTO_ALIAS(d2i_DIST_POINT)
 int
 i2d_DIST_POINT(DIST_POINT *a, unsigned char **out)
 {
        return ASN1_item_i2d((ASN1_VALUE *)a, out, &DIST_POINT_it);
 }
+LCRYPTO_ALIAS(i2d_DIST_POINT)
 DIST_POINT *
 DIST_POINT_new(void)
 {
        return (DIST_POINT *)ASN1_item_new(&DIST_POINT_it);
 }
+LCRYPTO_ALIAS(DIST_POINT_new)
 void
 DIST_POINT_free(DIST_POINT *a)
 {
        ASN1_item_free((ASN1_VALUE *)a, &DIST_POINT_it);
 }
+LCRYPTO_ALIAS(DIST_POINT_free)
 static const ASN1_TEMPLATE CRL_DIST_POINTS_item_tt = {
        .flags = ASN1_TFLG_SEQUENCE_OF,
@@ -530,24 +538,28 @@ d2i_CRL_DIST_POINTS(CRL_DIST_POINTS **a, const unsigned char **in, long len)
        return (CRL_DIST_POINTS *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
            &CRL_DIST_POINTS_it);
 }
+LCRYPTO_ALIAS(d2i_CRL_DIST_POINTS)
 int
 i2d_CRL_DIST_POINTS(CRL_DIST_POINTS *a, unsigned char **out)
 {
        return ASN1_item_i2d((ASN1_VALUE *)a, out, &CRL_DIST_POINTS_it);
 }
+LCRYPTO_ALIAS(i2d_CRL_DIST_POINTS)
 CRL_DIST_POINTS *
 CRL_DIST_POINTS_new(void)
 {
        return (CRL_DIST_POINTS *)ASN1_item_new(&CRL_DIST_POINTS_it);
 }
+LCRYPTO_ALIAS(CRL_DIST_POINTS_new)
 void
 CRL_DIST_POINTS_free(CRL_DIST_POINTS *a)
 {
        ASN1_item_free((ASN1_VALUE *)a, &CRL_DIST_POINTS_it);
 }
+LCRYPTO_ALIAS(CRL_DIST_POINTS_free)
 static const ASN1_TEMPLATE ISSUING_DIST_POINT_seq_tt[] = {
        {
@@ -611,24 +623,28 @@ d2i_ISSUING_DIST_POINT(ISSUING_DIST_POINT **a, const unsigned char **in, long le
        return (ISSUING_DIST_POINT *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
            &ISSUING_DIST_POINT_it);
 }
+LCRYPTO_ALIAS(d2i_ISSUING_DIST_POINT)
 int
 i2d_ISSUING_DIST_POINT(ISSUING_DIST_POINT *a, unsigned char **out)
 {
        return ASN1_item_i2d((ASN1_VALUE *)a, out, &ISSUING_DIST_POINT_it);
 }
+LCRYPTO_ALIAS(i2d_ISSUING_DIST_POINT)
 ISSUING_DIST_POINT *
 ISSUING_DIST_POINT_new(void)
 {
        return (ISSUING_DIST_POINT *)ASN1_item_new(&ISSUING_DIST_POINT_it);
 }
+LCRYPTO_ALIAS(ISSUING_DIST_POINT_new)
 void
 ISSUING_DIST_POINT_free(ISSUING_DIST_POINT *a)
 {
        ASN1_item_free((ASN1_VALUE *)a, &ISSUING_DIST_POINT_it);
 }
+LCRYPTO_ALIAS(ISSUING_DIST_POINT_free)
 static int i2r_idp(const X509V3_EXT_METHOD *method, void *pidp, BIO *out,
    int indent);
@@ -809,3 +825,4 @@ DIST_POINT_set_dpname(DIST_POINT_NAME *dpn, X509_NAME *iname)
        }
        return 1;
 }
+LCRYPTO_ALIAS(DIST_POINT_set_dpname)
diff --git a/src/lib/libcrypto/x509/x509_d2.c b/src/lib/libcrypto/x509/x509_d2.c
index 5b0f80adda..522062a694 100644
--- a/src/lib/libcrypto/x509/x509_d2.c
+++ b/src/lib/libcrypto/x509/x509_d2.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: x509_d2.c,v 1.10 2015/01/22 09:06:39 reyk Exp $ */
+/* $OpenBSD: x509_d2.c,v 1.11 2022/11/14 17:48:50 beck Exp $ */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
 * All rights reserved.
 *
@@ -83,6 +83,7 @@ X509_STORE_set_default_paths(X509_STORE *ctx)
        return (1);
 }
+LCRYPTO_ALIAS(X509_STORE_set_default_paths)
 int
 X509_STORE_load_locations(X509_STORE *ctx, const char *file, const char *path)
@@ -107,6 +108,7 @@ X509_STORE_load_locations(X509_STORE *ctx, const char *file, const char *path)
                return (0);
        return (1);
 }
+LCRYPTO_ALIAS(X509_STORE_load_locations)
 int
 X509_STORE_load_mem(X509_STORE *ctx, void *buf, int len)
@@ -126,3 +128,4 @@ X509_STORE_load_mem(X509_STORE *ctx, void *buf, int len)
        return (1);
 }
+LCRYPTO_ALIAS(X509_STORE_load_mem)
diff --git a/src/lib/libcrypto/x509/x509_def.c b/src/lib/libcrypto/x509/x509_def.c
index 5e570eb9a2..0d8900a526 100644
--- a/src/lib/libcrypto/x509/x509_def.c
+++ b/src/lib/libcrypto/x509/x509_def.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: x509_def.c,v 1.5 2014/06/12 15:49:31 deraadt Exp $ */
+/* $OpenBSD: x509_def.c,v 1.6 2022/11/14 17:48:50 beck Exp $ */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
 * All rights reserved.
 *
@@ -66,33 +66,39 @@ X509_get_default_private_dir(void)
 {
        return (X509_PRIVATE_DIR);
 }
+LCRYPTO_ALIAS(X509_get_default_private_dir)
 const char *
 X509_get_default_cert_area(void)
 {
        return (X509_CERT_AREA);
 }
+LCRYPTO_ALIAS(X509_get_default_cert_area)
 const char *
 X509_get_default_cert_dir(void)
 {
        return (X509_CERT_DIR);
 }
+LCRYPTO_ALIAS(X509_get_default_cert_dir)
 const char *
 X509_get_default_cert_file(void)
 {
        return (X509_CERT_FILE);
 }
+LCRYPTO_ALIAS(X509_get_default_cert_file)
 const char *
 X509_get_default_cert_dir_env(void)
 {
        return (X509_CERT_DIR_EVP);
 }
+LCRYPTO_ALIAS(X509_get_default_cert_dir_env)
 const char *
 X509_get_default_cert_file_env(void)
 {
        return (X509_CERT_FILE_EVP);
 }
+LCRYPTO_ALIAS(X509_get_default_cert_file_env)
diff --git a/src/lib/libcrypto/x509/x509_enum.c b/src/lib/libcrypto/x509/x509_enum.c
index f18eea535f..f0ab60a4b0 100644
--- a/src/lib/libcrypto/x509/x509_enum.c
+++ b/src/lib/libcrypto/x509/x509_enum.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: x509_enum.c,v 1.1 2020/06/04 15:19:31 jsing Exp $ */
+/* $OpenBSD: x509_enum.c,v 1.2 2022/11/14 17:48:50 beck Exp $ */
 /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
 * project 1999.
 */
@@ -105,3 +105,4 @@ i2s_ASN1_ENUMERATED_TABLE(X509V3_EXT_METHOD *method, const ASN1_ENUMERATED *e)
        }
        return i2s_ASN1_ENUMERATED(method, e);
 }
+LCRYPTO_ALIAS(i2s_ASN1_ENUMERATED_TABLE)
diff --git a/src/lib/libcrypto/x509/x509_err.c b/src/lib/libcrypto/x509/x509_err.c
index 588ed85411..c83655046a 100644
--- a/src/lib/libcrypto/x509/x509_err.c
+++ b/src/lib/libcrypto/x509/x509_err.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: x509_err.c,v 1.17 2022/07/12 14:42:50 kn Exp $ */
+/* $OpenBSD: x509_err.c,v 1.18 2022/11/14 17:48:50 beck Exp $ */
 /* ====================================================================
 * Copyright (c) 1999-2006 The OpenSSL Project.  All rights reserved.
 *
@@ -191,6 +191,7 @@ ERR_load_X509_strings(void)
        }
 #endif
 }
+LCRYPTO_ALIAS(ERR_load_X509_strings)
 void
@@ -203,3 +204,4 @@ ERR_load_X509V3_strings(void)
        }
 #endif
 }
+LCRYPTO_ALIAS(ERR_load_X509V3_strings)
diff --git a/src/lib/libcrypto/x509/x509_ext.c b/src/lib/libcrypto/x509/x509_ext.c
index 1445951199..95679265c3 100644
--- a/src/lib/libcrypto/x509/x509_ext.c
+++ b/src/lib/libcrypto/x509/x509_ext.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: x509_ext.c,v 1.13 2021/11/01 20:53:08 tb Exp $ */
+/* $OpenBSD: x509_ext.c,v 1.14 2022/11/14 17:48:50 beck Exp $ */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
 * All rights reserved.
 *
@@ -72,42 +72,49 @@ X509_CRL_get_ext_count(const X509_CRL *x)
 {
        return (X509v3_get_ext_count(x->crl->extensions));
 }
+LCRYPTO_ALIAS(X509_CRL_get_ext_count)
 int
 X509_CRL_get_ext_by_NID(const X509_CRL *x, int nid, int lastpos)
 {
        return (X509v3_get_ext_by_NID(x->crl->extensions, nid, lastpos));
 }
+LCRYPTO_ALIAS(X509_CRL_get_ext_by_NID)
 int
 X509_CRL_get_ext_by_OBJ(const X509_CRL *x, const ASN1_OBJECT *obj, int lastpos)
 {
        return (X509v3_get_ext_by_OBJ(x->crl->extensions, obj, lastpos));
 }
+LCRYPTO_ALIAS(X509_CRL_get_ext_by_OBJ)
 int
 X509_CRL_get_ext_by_critical(const X509_CRL *x, int crit, int lastpos)
 {
        return (X509v3_get_ext_by_critical(x->crl->extensions, crit, lastpos));
 }
+LCRYPTO_ALIAS(X509_CRL_get_ext_by_critical)
 X509_EXTENSION *
 X509_CRL_get_ext(const X509_CRL *x, int loc)
 {
        return (X509v3_get_ext(x->crl->extensions, loc));
 }
+LCRYPTO_ALIAS(X509_CRL_get_ext)
 X509_EXTENSION *
 X509_CRL_delete_ext(X509_CRL *x, int loc)
 {
        return (X509v3_delete_ext(x->crl->extensions, loc));
 }
+LCRYPTO_ALIAS(X509_CRL_delete_ext)
 void *
 X509_CRL_get_ext_d2i(const X509_CRL *x, int nid, int *crit, int *idx)
 {
        return X509V3_get_d2i(x->crl->extensions, nid, crit, idx);
 }
+LCRYPTO_ALIAS(X509_CRL_get_ext_d2i)
 int
 X509_CRL_add1_ext_i2d(X509_CRL *x, int nid, void *value, int crit,
@@ -115,30 +122,35 @@ X509_CRL_add1_ext_i2d(X509_CRL *x, int nid, void *value, int crit,
 {
        return X509V3_add1_i2d(&x->crl->extensions, nid, value, crit, flags);
 }
+LCRYPTO_ALIAS(X509_CRL_add1_ext_i2d)
 int
 X509_CRL_add_ext(X509_CRL *x, X509_EXTENSION *ex, int loc)
 {
        return (X509v3_add_ext(&(x->crl->extensions), ex, loc) != NULL);
 }
+LCRYPTO_ALIAS(X509_CRL_add_ext)
 int
 X509_get_ext_count(const X509 *x)
 {
        return (X509v3_get_ext_count(x->cert_info->extensions));
 }
+LCRYPTO_ALIAS(X509_get_ext_count)
 int
 X509_get_ext_by_NID(const X509 *x, int nid, int lastpos)
 {
        return (X509v3_get_ext_by_NID(x->cert_info->extensions, nid, lastpos));
 }
+LCRYPTO_ALIAS(X509_get_ext_by_NID)
 int
 X509_get_ext_by_OBJ(const X509 *x, const ASN1_OBJECT *obj, int lastpos)
 {
        return (X509v3_get_ext_by_OBJ(x->cert_info->extensions, obj, lastpos));
 }
+LCRYPTO_ALIAS(X509_get_ext_by_OBJ)
 int
 X509_get_ext_by_critical(const X509 *x, int crit, int lastpos)
@@ -146,30 +158,35 @@ X509_get_ext_by_critical(const X509 *x, int crit, int lastpos)
        return (X509v3_get_ext_by_critical(x->cert_info->extensions, crit,
            lastpos));
 }
+LCRYPTO_ALIAS(X509_get_ext_by_critical)
 X509_EXTENSION *
 X509_get_ext(const X509 *x, int loc)
 {
        return (X509v3_get_ext(x->cert_info->extensions, loc));
 }
+LCRYPTO_ALIAS(X509_get_ext)
 X509_EXTENSION *
 X509_delete_ext(X509 *x, int loc)
 {
        return (X509v3_delete_ext(x->cert_info->extensions, loc));
 }
+LCRYPTO_ALIAS(X509_delete_ext)
 int
 X509_add_ext(X509 *x, X509_EXTENSION *ex, int loc)
 {
        return (X509v3_add_ext(&(x->cert_info->extensions), ex, loc) != NULL);
 }
+LCRYPTO_ALIAS(X509_add_ext)
 void *
 X509_get_ext_d2i(const X509 *x, int nid, int *crit, int *idx)
 {
        return X509V3_get_d2i(x->cert_info->extensions, nid, crit, idx);
 }
+LCRYPTO_ALIAS(X509_get_ext_d2i)
 int
 X509_add1_ext_i2d(X509 *x, int nid, void *value, int crit, unsigned long flags)
@@ -177,18 +194,21 @@ X509_add1_ext_i2d(X509 *x, int nid, void *value, int crit, unsigned long flags)
        return X509V3_add1_i2d(&x->cert_info->extensions, nid, value, crit,
            flags);
 }
+LCRYPTO_ALIAS(X509_add1_ext_i2d)
 int
 X509_REVOKED_get_ext_count(const X509_REVOKED *x)
 {
        return (X509v3_get_ext_count(x->extensions));
 }
+LCRYPTO_ALIAS(X509_REVOKED_get_ext_count)
 int
 X509_REVOKED_get_ext_by_NID(const X509_REVOKED *x, int nid, int lastpos)
 {
        return (X509v3_get_ext_by_NID(x->extensions, nid, lastpos));
 }
+LCRYPTO_ALIAS(X509_REVOKED_get_ext_by_NID)
 int
 X509_REVOKED_get_ext_by_OBJ(const X509_REVOKED *x, const ASN1_OBJECT *obj,
@@ -196,36 +216,42 @@ X509_REVOKED_get_ext_by_OBJ(const X509_REVOKED *x, const ASN1_OBJECT *obj,
 {
        return (X509v3_get_ext_by_OBJ(x->extensions, obj, lastpos));
 }
+LCRYPTO_ALIAS(X509_REVOKED_get_ext_by_OBJ)
 int
 X509_REVOKED_get_ext_by_critical(const X509_REVOKED *x, int crit, int lastpos)
 {
        return (X509v3_get_ext_by_critical(x->extensions, crit, lastpos));
 }
+LCRYPTO_ALIAS(X509_REVOKED_get_ext_by_critical)
 X509_EXTENSION *
 X509_REVOKED_get_ext(const X509_REVOKED *x, int loc)
 {
        return (X509v3_get_ext(x->extensions, loc));
 }
+LCRYPTO_ALIAS(X509_REVOKED_get_ext)
 X509_EXTENSION *
 X509_REVOKED_delete_ext(X509_REVOKED *x, int loc)
 {
        return (X509v3_delete_ext(x->extensions, loc));
 }
+LCRYPTO_ALIAS(X509_REVOKED_delete_ext)
 int
 X509_REVOKED_add_ext(X509_REVOKED *x, X509_EXTENSION *ex, int loc)
 {
        return (X509v3_add_ext(&(x->extensions), ex, loc) != NULL);
 }
+LCRYPTO_ALIAS(X509_REVOKED_add_ext)
 void *
 X509_REVOKED_get_ext_d2i(const X509_REVOKED *x, int nid, int *crit, int *idx)
 {
        return X509V3_get_d2i(x->extensions, nid, crit, idx);
 }
+LCRYPTO_ALIAS(X509_REVOKED_get_ext_d2i)
 int
 X509_REVOKED_add1_ext_i2d(X509_REVOKED *x, int nid, void *value, int crit,
@@ -233,3 +259,4 @@ X509_REVOKED_add1_ext_i2d(X509_REVOKED *x, int nid, void *value, int crit,
 {
        return X509V3_add1_i2d(&x->extensions, nid, value, crit, flags);
 }
+LCRYPTO_ALIAS(X509_REVOKED_add1_ext_i2d)
diff --git a/src/lib/libcrypto/x509/x509_extku.c b/src/lib/libcrypto/x509/x509_extku.c
index 09bec675ac..cfdb23df75 100644
--- a/src/lib/libcrypto/x509/x509_extku.c
+++ b/src/lib/libcrypto/x509/x509_extku.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: x509_extku.c,v 1.1 2020/06/04 15:19:31 jsing Exp $ */
+/* $OpenBSD: x509_extku.c,v 1.2 2022/11/14 17:48:50 beck Exp $ */
 /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
 * project 1999.
 */
@@ -128,24 +128,28 @@ d2i_EXTENDED_KEY_USAGE(EXTENDED_KEY_USAGE **a, const unsigned char **in, long le
        return (EXTENDED_KEY_USAGE *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
            &EXTENDED_KEY_USAGE_it);
 }
+LCRYPTO_ALIAS(d2i_EXTENDED_KEY_USAGE)
 int
 i2d_EXTENDED_KEY_USAGE(EXTENDED_KEY_USAGE *a, unsigned char **out)
 {
        return ASN1_item_i2d((ASN1_VALUE *)a, out, &EXTENDED_KEY_USAGE_it);
 }
+LCRYPTO_ALIAS(i2d_EXTENDED_KEY_USAGE)
 EXTENDED_KEY_USAGE *
 EXTENDED_KEY_USAGE_new(void)
 {
        return (EXTENDED_KEY_USAGE *)ASN1_item_new(&EXTENDED_KEY_USAGE_it);
 }
+LCRYPTO_ALIAS(EXTENDED_KEY_USAGE_new)
 void
 EXTENDED_KEY_USAGE_free(EXTENDED_KEY_USAGE *a)
 {
        ASN1_item_free((ASN1_VALUE *)a, &EXTENDED_KEY_USAGE_it);
 }
+LCRYPTO_ALIAS(EXTENDED_KEY_USAGE_free)
 static STACK_OF(CONF_VALUE) *
 i2v_EXTENDED_KEY_USAGE(const X509V3_EXT_METHOD *method, void *a,
diff --git a/src/lib/libcrypto/x509/x509_genn.c b/src/lib/libcrypto/x509/x509_genn.c
index dadf6f1e40..ce1fb6cc02 100644
--- a/src/lib/libcrypto/x509/x509_genn.c
+++ b/src/lib/libcrypto/x509/x509_genn.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: x509_genn.c,v 1.2 2020/12/08 15:06:42 tb Exp $ */
+/* $OpenBSD: x509_genn.c,v 1.3 2022/11/14 17:48:50 beck Exp $ */
 /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
 * project 1999.
 */
@@ -98,24 +98,28 @@ d2i_OTHERNAME(OTHERNAME **a, const unsigned char **in, long len)
        return (OTHERNAME *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
            &OTHERNAME_it);
 }
+LCRYPTO_ALIAS(d2i_OTHERNAME)
 int
 i2d_OTHERNAME(OTHERNAME *a, unsigned char **out)
 {
        return ASN1_item_i2d((ASN1_VALUE *)a, out, &OTHERNAME_it);
 }
+LCRYPTO_ALIAS(i2d_OTHERNAME)
 OTHERNAME *
 OTHERNAME_new(void)
 {
        return (OTHERNAME *)ASN1_item_new(&OTHERNAME_it);
 }
+LCRYPTO_ALIAS(OTHERNAME_new)
 void
 OTHERNAME_free(OTHERNAME *a)
 {
        ASN1_item_free((ASN1_VALUE *)a, &OTHERNAME_it);
 }
+LCRYPTO_ALIAS(OTHERNAME_free)
 /* Uses explicit tagging since DIRECTORYSTRING is a CHOICE type */
 static const ASN1_TEMPLATE EDIPARTYNAME_seq_tt[] = {
@@ -152,24 +156,28 @@ d2i_EDIPARTYNAME(EDIPARTYNAME **a, const unsigned char **in, long len)
        return (EDIPARTYNAME *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
            &EDIPARTYNAME_it);
 }
+LCRYPTO_ALIAS(d2i_EDIPARTYNAME)
 int
 i2d_EDIPARTYNAME(EDIPARTYNAME *a, unsigned char **out)
 {
        return ASN1_item_i2d((ASN1_VALUE *)a, out, &EDIPARTYNAME_it);
 }
+LCRYPTO_ALIAS(i2d_EDIPARTYNAME)
 EDIPARTYNAME *
 EDIPARTYNAME_new(void)
 {
        return (EDIPARTYNAME *)ASN1_item_new(&EDIPARTYNAME_it);
 }
+LCRYPTO_ALIAS(EDIPARTYNAME_new)
 void
 EDIPARTYNAME_free(EDIPARTYNAME *a)
 {
        ASN1_item_free((ASN1_VALUE *)a, &EDIPARTYNAME_it);
 }
+LCRYPTO_ALIAS(EDIPARTYNAME_free)
 static const ASN1_TEMPLATE GENERAL_NAME_ch_tt[] = {
        {
@@ -256,24 +264,28 @@ d2i_GENERAL_NAME(GENERAL_NAME **a, const unsigned char **in, long len)
        return (GENERAL_NAME *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
            &GENERAL_NAME_it);
 }
+LCRYPTO_ALIAS(d2i_GENERAL_NAME)
 int
 i2d_GENERAL_NAME(GENERAL_NAME *a, unsigned char **out)
 {
        return ASN1_item_i2d((ASN1_VALUE *)a, out, &GENERAL_NAME_it);
 }
+LCRYPTO_ALIAS(i2d_GENERAL_NAME)
 GENERAL_NAME *
 GENERAL_NAME_new(void)
 {
        return (GENERAL_NAME *)ASN1_item_new(&GENERAL_NAME_it);
 }
+LCRYPTO_ALIAS(GENERAL_NAME_new)
 void
 GENERAL_NAME_free(GENERAL_NAME *a)
 {
        ASN1_item_free((ASN1_VALUE *)a, &GENERAL_NAME_it);
 }
+LCRYPTO_ALIAS(GENERAL_NAME_free)
 static const ASN1_TEMPLATE GENERAL_NAMES_item_tt = {
        .flags = ASN1_TFLG_SEQUENCE_OF,
@@ -300,30 +312,35 @@ d2i_GENERAL_NAMES(GENERAL_NAMES **a, const unsigned char **in, long len)
        return (GENERAL_NAMES *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
            &GENERAL_NAMES_it);
 }
+LCRYPTO_ALIAS(d2i_GENERAL_NAMES)
 int
 i2d_GENERAL_NAMES(GENERAL_NAMES *a, unsigned char **out)
 {
        return ASN1_item_i2d((ASN1_VALUE *)a, out, &GENERAL_NAMES_it);
 }
+LCRYPTO_ALIAS(i2d_GENERAL_NAMES)
 GENERAL_NAMES *
 GENERAL_NAMES_new(void)
 {
        return (GENERAL_NAMES *)ASN1_item_new(&GENERAL_NAMES_it);
 }
+LCRYPTO_ALIAS(GENERAL_NAMES_new)
 void
 GENERAL_NAMES_free(GENERAL_NAMES *a)
 {
        ASN1_item_free((ASN1_VALUE *)a, &GENERAL_NAMES_it);
 }
+LCRYPTO_ALIAS(GENERAL_NAMES_free)
 GENERAL_NAME *
 GENERAL_NAME_dup(GENERAL_NAME *a)
 {
        return ASN1_item_dup(&GENERAL_NAME_it, a);
 }
+LCRYPTO_ALIAS(GENERAL_NAME_dup)
 static int
 EDIPARTYNAME_cmp(const EDIPARTYNAME *a, const EDIPARTYNAME *b)
@@ -397,6 +414,7 @@ GENERAL_NAME_cmp(GENERAL_NAME *a, GENERAL_NAME *b)
        }
        return result;
 }
+LCRYPTO_ALIAS(GENERAL_NAME_cmp)
 /* Returns 0 if they are equal, != 0 otherwise. */
 int
@@ -413,6 +431,7 @@ OTHERNAME_cmp(OTHERNAME *a, OTHERNAME *b)
        result = ASN1_TYPE_cmp(a->value, b->value);
        return result;
 }
+LCRYPTO_ALIAS(OTHERNAME_cmp)
 void
 GENERAL_NAME_set0_value(GENERAL_NAME *a, int type, void *value)
@@ -450,6 +469,7 @@ GENERAL_NAME_set0_value(GENERAL_NAME *a, int type, void *value)
        }
        a->type = type;
 }
+LCRYPTO_ALIAS(GENERAL_NAME_set0_value)
 void *
 GENERAL_NAME_get0_value(GENERAL_NAME *a, int *ptype)
@@ -484,6 +504,7 @@ GENERAL_NAME_get0_value(GENERAL_NAME *a, int *ptype)
                return NULL;
        }
 }
+LCRYPTO_ALIAS(GENERAL_NAME_get0_value)
 int
 GENERAL_NAME_set0_othername(GENERAL_NAME *gen, ASN1_OBJECT *oid,
@@ -499,6 +520,7 @@ GENERAL_NAME_set0_othername(GENERAL_NAME *gen, ASN1_OBJECT *oid,
        GENERAL_NAME_set0_value(gen, GEN_OTHERNAME, oth);
        return 1;
 }
+LCRYPTO_ALIAS(GENERAL_NAME_set0_othername)
 int
 GENERAL_NAME_get0_otherName(GENERAL_NAME *gen, ASN1_OBJECT **poid,
@@ -512,3 +534,4 @@ GENERAL_NAME_get0_otherName(GENERAL_NAME *gen, ASN1_OBJECT **poid,
                *pvalue = gen->d.otherName->value;
        return 1;
 }
+LCRYPTO_ALIAS(GENERAL_NAME_get0_otherName)
diff --git a/src/lib/libcrypto/x509/x509_info.c b/src/lib/libcrypto/x509/x509_info.c
index 86ed6fadfa..6c7fd13601 100644
--- a/src/lib/libcrypto/x509/x509_info.c
+++ b/src/lib/libcrypto/x509/x509_info.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: x509_info.c,v 1.1 2020/06/04 15:19:31 jsing Exp $ */
+/* $OpenBSD: x509_info.c,v 1.2 2022/11/14 17:48:50 beck Exp $ */
 /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
 * project 1999.
 */
@@ -139,24 +139,28 @@ d2i_ACCESS_DESCRIPTION(ACCESS_DESCRIPTION **a, const unsigned char **in, long le
        return (ACCESS_DESCRIPTION *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
            &ACCESS_DESCRIPTION_it);
 }
+LCRYPTO_ALIAS(d2i_ACCESS_DESCRIPTION)
 int
 i2d_ACCESS_DESCRIPTION(ACCESS_DESCRIPTION *a, unsigned char **out)
 {
        return ASN1_item_i2d((ASN1_VALUE *)a, out, &ACCESS_DESCRIPTION_it);
 }
+LCRYPTO_ALIAS(i2d_ACCESS_DESCRIPTION)
 ACCESS_DESCRIPTION *
 ACCESS_DESCRIPTION_new(void)
 {
        return (ACCESS_DESCRIPTION *)ASN1_item_new(&ACCESS_DESCRIPTION_it);
 }
+LCRYPTO_ALIAS(ACCESS_DESCRIPTION_new)
 void
 ACCESS_DESCRIPTION_free(ACCESS_DESCRIPTION *a)
 {
        ASN1_item_free((ASN1_VALUE *)a, &ACCESS_DESCRIPTION_it);
 }
+LCRYPTO_ALIAS(ACCESS_DESCRIPTION_free)
 static const ASN1_TEMPLATE AUTHORITY_INFO_ACCESS_item_tt = {
        .flags = ASN1_TFLG_SEQUENCE_OF,
@@ -183,24 +187,28 @@ d2i_AUTHORITY_INFO_ACCESS(AUTHORITY_INFO_ACCESS **a, const unsigned char **in, l
        return (AUTHORITY_INFO_ACCESS *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
            &AUTHORITY_INFO_ACCESS_it);
 }
+LCRYPTO_ALIAS(d2i_AUTHORITY_INFO_ACCESS)
 int
 i2d_AUTHORITY_INFO_ACCESS(AUTHORITY_INFO_ACCESS *a, unsigned char **out)
 {
        return ASN1_item_i2d((ASN1_VALUE *)a, out, &AUTHORITY_INFO_ACCESS_it);
 }
+LCRYPTO_ALIAS(i2d_AUTHORITY_INFO_ACCESS)
 AUTHORITY_INFO_ACCESS *
 AUTHORITY_INFO_ACCESS_new(void)
 {
        return (AUTHORITY_INFO_ACCESS *)ASN1_item_new(&AUTHORITY_INFO_ACCESS_it);
 }
+LCRYPTO_ALIAS(AUTHORITY_INFO_ACCESS_new)
 void
 AUTHORITY_INFO_ACCESS_free(AUTHORITY_INFO_ACCESS *a)
 {
        ASN1_item_free((ASN1_VALUE *)a, &AUTHORITY_INFO_ACCESS_it);
 }
+LCRYPTO_ALIAS(AUTHORITY_INFO_ACCESS_free)
 static STACK_OF(CONF_VALUE) *
 i2v_AUTHORITY_INFO_ACCESS(X509V3_EXT_METHOD *method,
@@ -306,3 +314,4 @@ i2a_ACCESS_DESCRIPTION(BIO *bp, const ACCESS_DESCRIPTION* a)
        i2a_ASN1_OBJECT(bp, a->method);
        return 2;
 }
+LCRYPTO_ALIAS(i2a_ACCESS_DESCRIPTION)
diff --git a/src/lib/libcrypto/x509/x509_lib.c b/src/lib/libcrypto/x509/x509_lib.c
index e265d30f89..e209c055b6 100644
--- a/src/lib/libcrypto/x509/x509_lib.c
+++ b/src/lib/libcrypto/x509/x509_lib.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: x509_lib.c,v 1.4 2022/07/24 21:41:29 tb Exp $ */
+/* $OpenBSD: x509_lib.c,v 1.5 2022/11/14 17:48:50 beck Exp $ */
 /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
 * project 1999.
 */
@@ -85,6 +85,7 @@ X509V3_EXT_add(X509V3_EXT_METHOD *ext)
        }
        return 1;
 }
+LCRYPTO_ALIAS(X509V3_EXT_add)
 static int
 ext_cmp(const X509V3_EXT_METHOD * const *a, const X509V3_EXT_METHOD * const *b)
@@ -132,6 +133,7 @@ X509V3_EXT_get_nid(int nid)
                return NULL;
        return sk_X509V3_EXT_METHOD_value(ext_list, idx);
 }
+LCRYPTO_ALIAS(X509V3_EXT_get_nid)
 const X509V3_EXT_METHOD *
 X509V3_EXT_get(X509_EXTENSION *ext)
@@ -142,6 +144,7 @@ X509V3_EXT_get(X509_EXTENSION *ext)
                return NULL;
        return X509V3_EXT_get_nid(nid);
 }
+LCRYPTO_ALIAS(X509V3_EXT_get)
 int
 X509V3_EXT_add_list(X509V3_EXT_METHOD *extlist)
@@ -151,6 +154,7 @@ X509V3_EXT_add_list(X509V3_EXT_METHOD *extlist)
                        return 0;
        return 1;
 }
+LCRYPTO_ALIAS(X509V3_EXT_add_list)
 int
 X509V3_EXT_add_alias(int nid_to, int nid_from)
@@ -175,6 +179,7 @@ X509V3_EXT_add_alias(int nid_to, int nid_from)
        }
        return 1;
 }
+LCRYPTO_ALIAS(X509V3_EXT_add_alias)
 void
 X509V3_EXT_cleanup(void)
@@ -182,6 +187,7 @@ X509V3_EXT_cleanup(void)
        sk_X509V3_EXT_METHOD_pop_free(ext_list, ext_list_free);
        ext_list = NULL;
 }
+LCRYPTO_ALIAS(X509V3_EXT_cleanup)
 static void
 ext_list_free(X509V3_EXT_METHOD *ext)
@@ -199,6 +205,7 @@ X509V3_add_standard_extensions(void)
 {
        return 1;
 }
+LCRYPTO_ALIAS(X509V3_add_standard_extensions)
 /* Return an extension internal structure */
@@ -216,6 +223,7 @@ X509V3_EXT_d2i(X509_EXTENSION *ext)
                    method->it);
        return method->d2i(NULL, &p, ext->value->length);
 }
+LCRYPTO_ALIAS(X509V3_EXT_d2i)
 /* Get critical flag and decoded version of extension from a NID.
 * The "idx" variable returns the last found extension and can
@@ -281,6 +289,7 @@ X509V3_get_d2i(const STACK_OF(X509_EXTENSION) *x, int nid, int *crit, int *idx)
                *crit = -1;
        return NULL;
 }
+LCRYPTO_ALIAS(X509V3_get_d2i)
 /* This function is a general extension append, replace and delete utility.
 * The precise operation is governed by the 'flags' value. The 'crit' and
@@ -362,3 +371,4 @@ err:
                X509V3error(errcode);
        return 0;
 }
+LCRYPTO_ALIAS(X509V3_add1_i2d)
diff --git a/src/lib/libcrypto/x509/x509_lu.c b/src/lib/libcrypto/x509/x509_lu.c
index 90d75497dd..80ff1ed429 100644
--- a/src/lib/libcrypto/x509/x509_lu.c
+++ b/src/lib/libcrypto/x509/x509_lu.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: x509_lu.c,v 1.55 2022/01/14 07:53:45 tb Exp $ */
+/* $OpenBSD: x509_lu.c,v 1.56 2022/11/14 17:48:50 beck Exp $ */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
 * All rights reserved.
 *
@@ -84,6 +84,7 @@ X509_LOOKUP_new(X509_LOOKUP_METHOD *method)
        return lu;
 }
+LCRYPTO_ALIAS(X509_LOOKUP_new)
 void
 X509_LOOKUP_free(X509_LOOKUP *ctx)
@@ -94,6 +95,7 @@ X509_LOOKUP_free(X509_LOOKUP *ctx)
                ctx->method->free(ctx);
        free(ctx);
 }
+LCRYPTO_ALIAS(X509_LOOKUP_free)
 int
 X509_LOOKUP_init(X509_LOOKUP *ctx)
@@ -104,6 +106,7 @@ X509_LOOKUP_init(X509_LOOKUP *ctx)
                return 1;
        return ctx->method->init(ctx);
 }
+LCRYPTO_ALIAS(X509_LOOKUP_init)
 int
 X509_LOOKUP_shutdown(X509_LOOKUP *ctx)
@@ -114,6 +117,7 @@ X509_LOOKUP_shutdown(X509_LOOKUP *ctx)
                return 1;
        return ctx->method->shutdown(ctx);
 }
+LCRYPTO_ALIAS(X509_LOOKUP_shutdown)
 int
 X509_LOOKUP_ctrl(X509_LOOKUP *ctx, int cmd, const char *argc, long argl,
@@ -125,6 +129,7 @@ X509_LOOKUP_ctrl(X509_LOOKUP *ctx, int cmd, const char *argc, long argl,
                return 1;
        return ctx->method->ctrl(ctx, cmd, argc, argl, ret);
 }
+LCRYPTO_ALIAS(X509_LOOKUP_ctrl)
 int
 X509_LOOKUP_by_subject(X509_LOOKUP *ctx, X509_LOOKUP_TYPE type, X509_NAME *name,
@@ -134,6 +139,7 @@ X509_LOOKUP_by_subject(X509_LOOKUP *ctx, X509_LOOKUP_TYPE type, X509_NAME *name,
                return 0;
        return ctx->method->get_by_subject(ctx, type, name, ret);
 }
+LCRYPTO_ALIAS(X509_LOOKUP_by_subject)
 int
 X509_LOOKUP_by_issuer_serial(X509_LOOKUP *ctx, X509_LOOKUP_TYPE type,
@@ -143,6 +149,7 @@ X509_LOOKUP_by_issuer_serial(X509_LOOKUP *ctx, X509_LOOKUP_TYPE type,
                return 0;
        return ctx->method->get_by_issuer_serial(ctx, type, name, serial, ret);
 }
+LCRYPTO_ALIAS(X509_LOOKUP_by_issuer_serial)
 int
 X509_LOOKUP_by_fingerprint(X509_LOOKUP *ctx, X509_LOOKUP_TYPE type,
@@ -152,6 +159,7 @@ X509_LOOKUP_by_fingerprint(X509_LOOKUP *ctx, X509_LOOKUP_TYPE type,
                return 0;
        return ctx->method->get_by_fingerprint(ctx, type, bytes, len, ret);
 }
+LCRYPTO_ALIAS(X509_LOOKUP_by_fingerprint)
 int
 X509_LOOKUP_by_alias(X509_LOOKUP *ctx, X509_LOOKUP_TYPE type, const char *str,
@@ -161,6 +169,7 @@ X509_LOOKUP_by_alias(X509_LOOKUP *ctx, X509_LOOKUP_TYPE type, const char *str,
                return 0;
        return ctx->method->get_by_alias(ctx, type, str, len, ret);
 }
+LCRYPTO_ALIAS(X509_LOOKUP_by_alias)
 static int
 x509_object_cmp(const X509_OBJECT * const *a, const X509_OBJECT * const *b)
@@ -208,6 +217,7 @@ X509_STORE_new(void)
        return NULL;
 }
+LCRYPTO_ALIAS(X509_STORE_new)
 X509_OBJECT *
 X509_OBJECT_new(void)
@@ -223,6 +233,7 @@ X509_OBJECT_new(void)
        return obj;
 }
+LCRYPTO_ALIAS(X509_OBJECT_new)
 void
 X509_OBJECT_free(X509_OBJECT *a)
@@ -241,6 +252,7 @@ X509_OBJECT_free(X509_OBJECT *a)
        free(a);
 }
+LCRYPTO_ALIAS(X509_OBJECT_free)
 void
 X509_STORE_free(X509_STORE *store)
@@ -268,12 +280,14 @@ X509_STORE_free(X509_STORE *store)
        X509_VERIFY_PARAM_free(store->param);
        free(store);
 }
+LCRYPTO_ALIAS(X509_STORE_free)
 int
 X509_STORE_up_ref(X509_STORE *store)
 {
        return CRYPTO_add(&store->references, 1, CRYPTO_LOCK_X509_STORE) > 1;
 }
+LCRYPTO_ALIAS(X509_STORE_up_ref)
 X509_LOOKUP *
 X509_STORE_add_lookup(X509_STORE *store, X509_LOOKUP_METHOD *method)
@@ -302,6 +316,7 @@ X509_STORE_add_lookup(X509_STORE *store, X509_LOOKUP_METHOD *method)
        return lu;
 }
+LCRYPTO_ALIAS(X509_STORE_add_lookup)
 X509_OBJECT *
 X509_STORE_CTX_get_obj_by_subject(X509_STORE_CTX *vs, X509_LOOKUP_TYPE type,
@@ -318,6 +333,7 @@ X509_STORE_CTX_get_obj_by_subject(X509_STORE_CTX *vs, X509_LOOKUP_TYPE type,
        return obj;
 }
+LCRYPTO_ALIAS(X509_STORE_CTX_get_obj_by_subject)
 int
 X509_STORE_CTX_get_by_subject(X509_STORE_CTX *vs, X509_LOOKUP_TYPE type,
@@ -356,6 +372,7 @@ X509_STORE_CTX_get_by_subject(X509_STORE_CTX *vs, X509_LOOKUP_TYPE type,
        return 1;
 }
+LCRYPTO_ALIAS(X509_STORE_CTX_get_by_subject)
 /* Add obj to the store. Takes ownership of obj. */
 static int
@@ -407,6 +424,7 @@ X509_STORE_add_cert(X509_STORE *store, X509 *x)
        return X509_STORE_add_object(store, obj);
 }
+LCRYPTO_ALIAS(X509_STORE_add_cert)
 int
 X509_STORE_add_crl(X509_STORE *store, X509_CRL *x)
@@ -429,6 +447,7 @@ X509_STORE_add_crl(X509_STORE *store, X509_CRL *x)
        return X509_STORE_add_object(store, obj);
 }
+LCRYPTO_ALIAS(X509_STORE_add_crl)
 int
 X509_OBJECT_up_ref_count(X509_OBJECT *a)
@@ -441,12 +460,14 @@ X509_OBJECT_up_ref_count(X509_OBJECT *a)
        }
        return 1;
 }
+LCRYPTO_ALIAS(X509_OBJECT_up_ref_count)
 X509_LOOKUP_TYPE
 X509_OBJECT_get_type(const X509_OBJECT *a)
 {
        return a->type;
 }
+LCRYPTO_ALIAS(X509_OBJECT_get_type)
 static int
 x509_object_idx_cnt(STACK_OF(X509_OBJECT) *h, X509_LOOKUP_TYPE type,
@@ -498,6 +519,7 @@ X509_OBJECT_idx_by_subject(STACK_OF(X509_OBJECT) *h, X509_LOOKUP_TYPE type,
 {
        return x509_object_idx_cnt(h, type, name, NULL);
 }
+LCRYPTO_ALIAS(X509_OBJECT_idx_by_subject)
 X509_OBJECT *
 X509_OBJECT_retrieve_by_subject(STACK_OF(X509_OBJECT) *h, X509_LOOKUP_TYPE type,
@@ -510,6 +532,7 @@ X509_OBJECT_retrieve_by_subject(STACK_OF(X509_OBJECT) *h, X509_LOOKUP_TYPE type,
                return NULL;
        return sk_X509_OBJECT_value(h, idx);
 }
+LCRYPTO_ALIAS(X509_OBJECT_retrieve_by_subject)
 X509 *
 X509_OBJECT_get0_X509(const X509_OBJECT *xo)
@@ -518,6 +541,7 @@ X509_OBJECT_get0_X509(const X509_OBJECT *xo)
                return xo->data.x509;
        return NULL;
 }
+LCRYPTO_ALIAS(X509_OBJECT_get0_X509)
 X509_CRL *
 X509_OBJECT_get0_X509_CRL(X509_OBJECT *xo)
@@ -526,6 +550,7 @@ X509_OBJECT_get0_X509_CRL(X509_OBJECT *xo)
                return xo->data.crl;
        return NULL;
 }
+LCRYPTO_ALIAS(X509_OBJECT_get0_X509_CRL)
 static STACK_OF(X509) *
 X509_get1_certs_from_cache(X509_STORE *store, X509_NAME *name)
@@ -589,6 +614,7 @@ X509_STORE_get1_certs(X509_STORE_CTX *ctx, X509_NAME *name)
        return X509_get1_certs_from_cache(store, name);
 }
+LCRYPTO_ALIAS(X509_STORE_get1_certs)
 STACK_OF(X509_CRL) *
 X509_STORE_get1_crls(X509_STORE_CTX *ctx, X509_NAME *name)
@@ -639,6 +665,7 @@ X509_STORE_get1_crls(X509_STORE_CTX *ctx, X509_NAME *name)
        sk_X509_CRL_pop_free(sk, X509_CRL_free);
        return NULL;
 }
+LCRYPTO_ALIAS(X509_STORE_get1_crls)
 X509_OBJECT *
 X509_OBJECT_retrieve_match(STACK_OF(X509_OBJECT) *h, X509_OBJECT *x)
@@ -667,6 +694,7 @@ X509_OBJECT_retrieve_match(STACK_OF(X509_OBJECT) *h, X509_OBJECT *x)
        }
        return NULL;
 }
+LCRYPTO_ALIAS(X509_OBJECT_retrieve_match)
 /* Try to get issuer certificate from store. Due to limitations
 * of the API this can only retrieve a single certificate matching
@@ -757,30 +785,35 @@ X509_STORE_CTX_get1_issuer(X509 **out_issuer, X509_STORE_CTX *ctx, X509 *x)
        CRYPTO_w_unlock(CRYPTO_LOCK_X509_STORE);
        return ret;
 }
+LCRYPTO_ALIAS(X509_STORE_CTX_get1_issuer)
 STACK_OF(X509_OBJECT) *
 X509_STORE_get0_objects(X509_STORE *xs)
 {
        return xs->objs;
 }
+LCRYPTO_ALIAS(X509_STORE_get0_objects)
 void *
 X509_STORE_get_ex_data(X509_STORE *xs, int idx)
 {
        return CRYPTO_get_ex_data(&xs->ex_data, idx);
 }
+LCRYPTO_ALIAS(X509_STORE_get_ex_data)
 int
 X509_STORE_set_ex_data(X509_STORE *xs, int idx, void *data)
 {
        return CRYPTO_set_ex_data(&xs->ex_data, idx, data);
 }
+LCRYPTO_ALIAS(X509_STORE_set_ex_data)
 int
 X509_STORE_set_flags(X509_STORE *ctx, unsigned long flags)
 {
        return X509_VERIFY_PARAM_set_flags(ctx->param, flags);
 }
+LCRYPTO_ALIAS(X509_STORE_set_flags)
 int
 X509_STORE_set_depth(X509_STORE *ctx, int depth)
@@ -788,51 +821,60 @@ X509_STORE_set_depth(X509_STORE *ctx, int depth)
        X509_VERIFY_PARAM_set_depth(ctx->param, depth);
        return 1;
 }
+LCRYPTO_ALIAS(X509_STORE_set_depth)
 int
 X509_STORE_set_purpose(X509_STORE *ctx, int purpose)
 {
        return X509_VERIFY_PARAM_set_purpose(ctx->param, purpose);
 }
+LCRYPTO_ALIAS(X509_STORE_set_purpose)
 int
 X509_STORE_set_trust(X509_STORE *ctx, int trust)
 {
        return X509_VERIFY_PARAM_set_trust(ctx->param, trust);
 }
+LCRYPTO_ALIAS(X509_STORE_set_trust)
 int
 X509_STORE_set1_param(X509_STORE *ctx, X509_VERIFY_PARAM *param)
 {
        return X509_VERIFY_PARAM_set1(ctx->param, param);
 }
+LCRYPTO_ALIAS(X509_STORE_set1_param)
 X509_VERIFY_PARAM *
 X509_STORE_get0_param(X509_STORE *ctx)
 {
        return ctx->param;
 }
+LCRYPTO_ALIAS(X509_STORE_get0_param)
 void
 X509_STORE_set_verify(X509_STORE *store, X509_STORE_CTX_verify_fn verify)
 {
        store->verify = verify;
 }
+LCRYPTO_ALIAS(X509_STORE_set_verify)
 X509_STORE_CTX_verify_fn
 X509_STORE_get_verify(X509_STORE *store)
 {
        return store->verify;
 }
+LCRYPTO_ALIAS(X509_STORE_get_verify)
 void
 X509_STORE_set_verify_cb(X509_STORE *store, X509_STORE_CTX_verify_cb verify_cb)
 {
        store->verify_cb = verify_cb;
 }
+LCRYPTO_ALIAS(X509_STORE_set_verify_cb)
 X509_STORE_CTX_verify_cb
 X509_STORE_get_verify_cb(X509_STORE *store)
 {
        return store->verify_cb;
 }
+LCRYPTO_ALIAS(X509_STORE_get_verify_cb)
diff --git a/src/lib/libcrypto/x509/x509_ncons.c b/src/lib/libcrypto/x509/x509_ncons.c
index 613527005a..a5d055ae9f 100644
--- a/src/lib/libcrypto/x509/x509_ncons.c
+++ b/src/lib/libcrypto/x509/x509_ncons.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: x509_ncons.c,v 1.5 2021/11/01 20:53:08 tb Exp $ */
+/* $OpenBSD: x509_ncons.c,v 1.6 2022/11/14 17:48:50 beck Exp $ */
 /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
 * project.
 */
@@ -165,24 +165,28 @@ GENERAL_SUBTREE_new(void)
 {
        return (GENERAL_SUBTREE*)ASN1_item_new(&GENERAL_SUBTREE_it);
 }
+LCRYPTO_ALIAS(GENERAL_SUBTREE_new)
 void
 GENERAL_SUBTREE_free(GENERAL_SUBTREE *a)
 {
        ASN1_item_free((ASN1_VALUE *)a, &GENERAL_SUBTREE_it);
 }
+LCRYPTO_ALIAS(GENERAL_SUBTREE_free)
 NAME_CONSTRAINTS *
 NAME_CONSTRAINTS_new(void)
 {
        return (NAME_CONSTRAINTS*)ASN1_item_new(&NAME_CONSTRAINTS_it);
 }
+LCRYPTO_ALIAS(NAME_CONSTRAINTS_new)
 void
 NAME_CONSTRAINTS_free(NAME_CONSTRAINTS *a)
 {
        ASN1_item_free((ASN1_VALUE *)a, &NAME_CONSTRAINTS_it);
 }
+LCRYPTO_ALIAS(NAME_CONSTRAINTS_free)
 static void *
 v2i_NAME_CONSTRAINTS(const X509V3_EXT_METHOD *method, X509V3_CTX *ctx,
@@ -349,6 +353,7 @@ NAME_CONSTRAINTS_check(X509 *x, NAME_CONSTRAINTS *nc)
        }
        return X509_V_OK;
 }
+LCRYPTO_ALIAS(NAME_CONSTRAINTS_check)
 static int
 nc_match(GENERAL_NAME *gen, NAME_CONSTRAINTS *nc)
 {
diff --git a/src/lib/libcrypto/x509/x509_obj.c b/src/lib/libcrypto/x509/x509_obj.c
index 58ffa3a2f2..d27e59c741 100644
--- a/src/lib/libcrypto/x509/x509_obj.c
+++ b/src/lib/libcrypto/x509/x509_obj.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: x509_obj.c,v 1.19 2021/11/01 20:53:08 tb Exp $ */
+/* $OpenBSD: x509_obj.c,v 1.20 2022/11/14 17:48:50 beck Exp $ */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
 * All rights reserved.
 *
@@ -179,3 +179,4 @@ err:
                BUF_MEM_free(b);
        return (NULL);
 }
+LCRYPTO_ALIAS(X509_NAME_oneline)
diff --git a/src/lib/libcrypto/x509/x509_pcia.c b/src/lib/libcrypto/x509/x509_pcia.c
index b639aa336d..fb14384e99 100644
--- a/src/lib/libcrypto/x509/x509_pcia.c
+++ b/src/lib/libcrypto/x509/x509_pcia.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: x509_pcia.c,v 1.1 2020/06/04 15:19:32 jsing Exp $ */
+/* $OpenBSD: x509_pcia.c,v 1.2 2022/11/14 17:48:50 beck Exp $ */
 /* Contributed to the OpenSSL Project 2004
 * by Richard Levitte (richard@levitte.org)
 */
@@ -72,24 +72,28 @@ d2i_PROXY_POLICY(PROXY_POLICY **a, const unsigned char **in, long len)
        return (PROXY_POLICY *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
            &PROXY_POLICY_it);
 }
+LCRYPTO_ALIAS(d2i_PROXY_POLICY)
 int
 i2d_PROXY_POLICY(PROXY_POLICY *a, unsigned char **out)
 {
        return ASN1_item_i2d((ASN1_VALUE *)a, out, &PROXY_POLICY_it);
 }
+LCRYPTO_ALIAS(i2d_PROXY_POLICY)
 PROXY_POLICY *
 PROXY_POLICY_new(void)
 {
        return (PROXY_POLICY *)ASN1_item_new(&PROXY_POLICY_it);
 }
+LCRYPTO_ALIAS(PROXY_POLICY_new)
 void
 PROXY_POLICY_free(PROXY_POLICY *a)
 {
        ASN1_item_free((ASN1_VALUE *)a, &PROXY_POLICY_it);
 }
+LCRYPTO_ALIAS(PROXY_POLICY_free)
 static const ASN1_TEMPLATE PROXY_CERT_INFO_EXTENSION_seq_tt[] = {
        {
@@ -125,21 +129,25 @@ d2i_PROXY_CERT_INFO_EXTENSION(PROXY_CERT_INFO_EXTENSION **a, const unsigned char
        return (PROXY_CERT_INFO_EXTENSION *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
            &PROXY_CERT_INFO_EXTENSION_it);
 }
+LCRYPTO_ALIAS(d2i_PROXY_CERT_INFO_EXTENSION)
 int
 i2d_PROXY_CERT_INFO_EXTENSION(PROXY_CERT_INFO_EXTENSION *a, unsigned char **out)
 {
        return ASN1_item_i2d((ASN1_VALUE *)a, out, &PROXY_CERT_INFO_EXTENSION_it);
 }
+LCRYPTO_ALIAS(i2d_PROXY_CERT_INFO_EXTENSION)
 PROXY_CERT_INFO_EXTENSION *
 PROXY_CERT_INFO_EXTENSION_new(void)
 {
        return (PROXY_CERT_INFO_EXTENSION *)ASN1_item_new(&PROXY_CERT_INFO_EXTENSION_it);
 }
+LCRYPTO_ALIAS(PROXY_CERT_INFO_EXTENSION_new)
 void
 PROXY_CERT_INFO_EXTENSION_free(PROXY_CERT_INFO_EXTENSION *a)
 {
        ASN1_item_free((ASN1_VALUE *)a, &PROXY_CERT_INFO_EXTENSION_it);
 }
+LCRYPTO_ALIAS(PROXY_CERT_INFO_EXTENSION_free)
diff --git a/src/lib/libcrypto/x509/x509_pcons.c b/src/lib/libcrypto/x509/x509_pcons.c
index 69bf43377f..2448147fdb 100644
--- a/src/lib/libcrypto/x509/x509_pcons.c
+++ b/src/lib/libcrypto/x509/x509_pcons.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: x509_pcons.c,v 1.1 2020/06/04 15:19:32 jsing Exp $ */
+/* $OpenBSD: x509_pcons.c,v 1.2 2022/11/14 17:48:50 beck Exp $ */
 /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
 * project.
 */
@@ -121,12 +121,14 @@ POLICY_CONSTRAINTS_new(void)
 {
        return (POLICY_CONSTRAINTS*)ASN1_item_new(&POLICY_CONSTRAINTS_it);
 }
+LCRYPTO_ALIAS(POLICY_CONSTRAINTS_new)
 void
 POLICY_CONSTRAINTS_free(POLICY_CONSTRAINTS *a)
 {
        ASN1_item_free((ASN1_VALUE *)a, &POLICY_CONSTRAINTS_it);
 }
+LCRYPTO_ALIAS(POLICY_CONSTRAINTS_free)
 static STACK_OF(CONF_VALUE) *
 i2v_POLICY_CONSTRAINTS(const X509V3_EXT_METHOD *method, void *a,
diff --git a/src/lib/libcrypto/x509/x509_pku.c b/src/lib/libcrypto/x509/x509_pku.c
index 9b82ad3d5f..f65d0dfc69 100644
--- a/src/lib/libcrypto/x509/x509_pku.c
+++ b/src/lib/libcrypto/x509/x509_pku.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: x509_pku.c,v 1.1 2020/06/04 15:19:32 jsing Exp $ */
+/* $OpenBSD: x509_pku.c,v 1.2 2022/11/14 17:48:50 beck Exp $ */
 /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
 * project 1999.
 */
@@ -116,24 +116,28 @@ d2i_PKEY_USAGE_PERIOD(PKEY_USAGE_PERIOD **a, const unsigned char **in, long len)
        return (PKEY_USAGE_PERIOD *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
            &PKEY_USAGE_PERIOD_it);
 }
+LCRYPTO_ALIAS(d2i_PKEY_USAGE_PERIOD)
 int
 i2d_PKEY_USAGE_PERIOD(PKEY_USAGE_PERIOD *a, unsigned char **out)
 {
        return ASN1_item_i2d((ASN1_VALUE *)a, out, &PKEY_USAGE_PERIOD_it);
 }
+LCRYPTO_ALIAS(i2d_PKEY_USAGE_PERIOD)
 PKEY_USAGE_PERIOD *
 PKEY_USAGE_PERIOD_new(void)
 {
        return (PKEY_USAGE_PERIOD *)ASN1_item_new(&PKEY_USAGE_PERIOD_it);
 }
+LCRYPTO_ALIAS(PKEY_USAGE_PERIOD_new)
 void
 PKEY_USAGE_PERIOD_free(PKEY_USAGE_PERIOD *a)
 {
        ASN1_item_free((ASN1_VALUE *)a, &PKEY_USAGE_PERIOD_it);
 }
+LCRYPTO_ALIAS(PKEY_USAGE_PERIOD_free)
 static int
 i2r_PKEY_USAGE_PERIOD(X509V3_EXT_METHOD *method, PKEY_USAGE_PERIOD *usage,
diff --git a/src/lib/libcrypto/x509/x509_pmaps.c b/src/lib/libcrypto/x509/x509_pmaps.c
index 352f85a025..3bc4b9d637 100644
--- a/src/lib/libcrypto/x509/x509_pmaps.c
+++ b/src/lib/libcrypto/x509/x509_pmaps.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: x509_pmaps.c,v 1.1 2020/06/04 15:19:32 jsing Exp $ */
+/* $OpenBSD: x509_pmaps.c,v 1.2 2022/11/14 17:48:50 beck Exp $ */
 /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
 * project.
 */
@@ -137,12 +137,14 @@ POLICY_MAPPING_new(void)
 {
        return (POLICY_MAPPING*)ASN1_item_new(&POLICY_MAPPING_it);
 }
+LCRYPTO_ALIAS(POLICY_MAPPING_new)
 void
 POLICY_MAPPING_free(POLICY_MAPPING *a)
 {
        ASN1_item_free((ASN1_VALUE *)a, &POLICY_MAPPING_it);
 }
+LCRYPTO_ALIAS(POLICY_MAPPING_free)
 static STACK_OF(CONF_VALUE) *
 i2v_POLICY_MAPPINGS(const X509V3_EXT_METHOD *method, void *a,
diff --git a/src/lib/libcrypto/x509/x509_prn.c b/src/lib/libcrypto/x509/x509_prn.c
index 4977051d4a..b7db631500 100644
--- a/src/lib/libcrypto/x509/x509_prn.c
+++ b/src/lib/libcrypto/x509/x509_prn.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: x509_prn.c,v 1.2 2021/11/01 20:53:08 tb Exp $ */
+/* $OpenBSD: x509_prn.c,v 1.3 2022/11/14 17:48:50 beck Exp $ */
 /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
 * project 1999.
 */
@@ -99,6 +99,7 @@ X509V3_EXT_val_prn(BIO *out, STACK_OF(CONF_VALUE) *val, int indent, int ml)
                        BIO_puts(out, "\n");
        }
 }
+LCRYPTO_ALIAS(X509V3_EXT_val_prn)
 /* Main routine: print out a general extension */
@@ -152,6 +153,7 @@ err:
                method->ext_free(ext_str);
        return ok;
 }
+LCRYPTO_ALIAS(X509V3_EXT_print)
 int
 X509V3_extensions_print(BIO *bp, const char *title,
@@ -187,6 +189,7 @@ X509V3_extensions_print(BIO *bp, const char *title,
        }
        return 1;
 }
+LCRYPTO_ALIAS(X509V3_extensions_print)
 static int
 unknown_ext_print(BIO *out, X509_EXTENSION *ext, unsigned long flag,
@@ -225,3 +228,4 @@ X509V3_EXT_print_fp(FILE *fp, X509_EXTENSION *ext, int flag, int indent)
        BIO_free(bio_tmp);
        return ret;
 }
+LCRYPTO_ALIAS(X509V3_EXT_print_fp)
diff --git a/src/lib/libcrypto/x509/x509_purp.c b/src/lib/libcrypto/x509/x509_purp.c
index ab5e7cb3c9..d5027377bf 100644
--- a/src/lib/libcrypto/x509/x509_purp.c
+++ b/src/lib/libcrypto/x509/x509_purp.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: x509_purp.c,v 1.16 2022/05/10 19:42:52 tb Exp $ */
+/* $OpenBSD: x509_purp.c,v 1.17 2022/11/14 17:48:50 beck Exp $ */
 /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
 * project 2001.
 */
@@ -146,6 +146,7 @@ X509_check_purpose(X509 *x, int id, int ca)
        pt = X509_PURPOSE_get0(idx);
        return pt->check_purpose(pt, x, ca);
 }
+LCRYPTO_ALIAS(X509_check_purpose)
 int
 X509_PURPOSE_set(int *p, int purpose)
@@ -157,6 +158,7 @@ X509_PURPOSE_set(int *p, int purpose)
        *p = purpose;
        return 1;
 }
+LCRYPTO_ALIAS(X509_PURPOSE_set)
 int
 X509_PURPOSE_get_count(void)
@@ -165,6 +167,7 @@ X509_PURPOSE_get_count(void)
                return X509_PURPOSE_COUNT;
        return sk_X509_PURPOSE_num(xptable) + X509_PURPOSE_COUNT;
 }
+LCRYPTO_ALIAS(X509_PURPOSE_get_count)
 X509_PURPOSE *
 X509_PURPOSE_get0(int idx)
@@ -175,6 +178,7 @@ X509_PURPOSE_get0(int idx)
                return xstandard + idx;
        return sk_X509_PURPOSE_value(xptable, idx - X509_PURPOSE_COUNT);
 }
+LCRYPTO_ALIAS(X509_PURPOSE_get0)
 int
 X509_PURPOSE_get_by_sname(const char *sname)
@@ -189,6 +193,7 @@ X509_PURPOSE_get_by_sname(const char *sname)
        }
        return -1;
 }
+LCRYPTO_ALIAS(X509_PURPOSE_get_by_sname)
 int
 X509_PURPOSE_get_by_id(int purpose)
@@ -206,6 +211,7 @@ X509_PURPOSE_get_by_id(int purpose)
                return -1;
        return idx + X509_PURPOSE_COUNT;
 }
+LCRYPTO_ALIAS(X509_PURPOSE_get_by_id)
 int
 X509_PURPOSE_add(int id, int trust, int flags,
@@ -280,6 +286,7 @@ err:
        X509V3error(ERR_R_MALLOC_FAILURE);
        return 0;
 }
+LCRYPTO_ALIAS(X509_PURPOSE_add)
 static void
 xptable_free(X509_PURPOSE *p)
@@ -301,30 +308,35 @@ X509_PURPOSE_cleanup(void)
        sk_X509_PURPOSE_pop_free(xptable, xptable_free);
        xptable = NULL;
 }
+LCRYPTO_ALIAS(X509_PURPOSE_cleanup)
 int
 X509_PURPOSE_get_id(const X509_PURPOSE *xp)
 {
        return xp->purpose;
 }
+LCRYPTO_ALIAS(X509_PURPOSE_get_id)
 char *
 X509_PURPOSE_get0_name(const X509_PURPOSE *xp)
 {
        return xp->name;
 }
+LCRYPTO_ALIAS(X509_PURPOSE_get0_name)
 char *
 X509_PURPOSE_get0_sname(const X509_PURPOSE *xp)
 {
        return xp->sname;
 }
+LCRYPTO_ALIAS(X509_PURPOSE_get0_sname)
 int
 X509_PURPOSE_get_trust(const X509_PURPOSE *xp)
 {
        return xp->trust;
 }
+LCRYPTO_ALIAS(X509_PURPOSE_get_trust)
 static int
 nid_cmp(const int *a, const int *b)
@@ -390,6 +402,7 @@ X509_supported_extension(X509_EXTENSION *ex)
                return 1;
        return 0;
 }
+LCRYPTO_ALIAS(X509_supported_extension)
 static void
 setup_dp(X509 *x, DIST_POINT *dp)
@@ -675,6 +688,7 @@ X509_check_ca(X509 *x)
        return check_ca(x);
 }
+LCRYPTO_ALIAS(X509_check_ca)
 /* Check SSL CA: common checks for SSL client and server */
 static int
@@ -909,6 +923,7 @@ X509_check_issued(X509 *issuer, X509 *subject)
                return X509_V_ERR_KEYUSAGE_NO_CERTSIGN;
        return X509_V_OK;
 }
+LCRYPTO_ALIAS(X509_check_issued)
 int
 X509_check_akid(X509 *issuer, AUTHORITY_KEYID *akid)
@@ -948,6 +963,7 @@ X509_check_akid(X509 *issuer, AUTHORITY_KEYID *akid)
        }
        return X509_V_OK;
 }
+LCRYPTO_ALIAS(X509_check_akid)
 uint32_t
 X509_get_extension_flags(X509 *x)
@@ -958,6 +974,7 @@ X509_get_extension_flags(X509 *x)
        return x->ex_flags;
 }
+LCRYPTO_ALIAS(X509_get_extension_flags)
 uint32_t
 X509_get_key_usage(X509 *x)
@@ -971,6 +988,7 @@ X509_get_key_usage(X509 *x)
        return UINT32_MAX;
 }
+LCRYPTO_ALIAS(X509_get_key_usage)
 uint32_t
 X509_get_extended_key_usage(X509 *x)
@@ -984,3 +1002,4 @@ X509_get_extended_key_usage(X509 *x)
        return UINT32_MAX;
 }
+LCRYPTO_ALIAS(X509_get_extended_key_usage)
diff --git a/src/lib/libcrypto/x509/x509_r2x.c b/src/lib/libcrypto/x509/x509_r2x.c
index b3b8aa75ed..e69b54fc5b 100644
--- a/src/lib/libcrypto/x509/x509_r2x.c
+++ b/src/lib/libcrypto/x509/x509_r2x.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: x509_r2x.c,v 1.13 2021/11/03 14:36:21 schwarze Exp $ */
+/* $OpenBSD: x509_r2x.c,v 1.14 2022/11/14 17:48:50 beck Exp $ */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
 * All rights reserved.
 *
@@ -116,3 +116,4 @@ err:
        X509_free(ret);
        return NULL;
 }
+LCRYPTO_ALIAS(X509_REQ_to_X509)
diff --git a/src/lib/libcrypto/x509/x509_req.c b/src/lib/libcrypto/x509/x509_req.c
index c0a2a64a0b..5155d743ab 100644
--- a/src/lib/libcrypto/x509/x509_req.c
+++ b/src/lib/libcrypto/x509/x509_req.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: x509_req.c,v 1.29 2022/08/18 16:26:33 tb Exp $ */
+/* $OpenBSD: x509_req.c,v 1.30 2022/11/14 17:48:50 beck Exp $ */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
 * All rights reserved.
 *
@@ -115,6 +115,7 @@ err:
        X509_REQ_free(ret);
        return (NULL);
 }
+LCRYPTO_ALIAS(X509_to_X509_REQ)
 EVP_PKEY *
 X509_REQ_get_pubkey(X509_REQ *req)
@@ -123,6 +124,7 @@ X509_REQ_get_pubkey(X509_REQ *req)
                return (NULL);
        return (X509_PUBKEY_get(req->req_info->pubkey));
 }
+LCRYPTO_ALIAS(X509_REQ_get_pubkey)
 EVP_PKEY *
 X509_REQ_get0_pubkey(X509_REQ *req)
@@ -131,6 +133,7 @@ X509_REQ_get0_pubkey(X509_REQ *req)
                return NULL;
        return X509_PUBKEY_get0(req->req_info->pubkey);
 }
+LCRYPTO_ALIAS(X509_REQ_get0_pubkey)
 int
 X509_REQ_check_private_key(X509_REQ *x, EVP_PKEY *k)
@@ -170,6 +173,7 @@ X509_REQ_check_private_key(X509_REQ *x, EVP_PKEY *k)
        return (ok);
 }
+LCRYPTO_ALIAS(X509_REQ_check_private_key)
 /* It seems several organisations had the same idea of including a list of
 * extensions in a certificate request. There are at least two OIDs that are
@@ -193,18 +197,21 @@ X509_REQ_extension_nid(int req_nid)
                        return 1;
        }
 }
+LCRYPTO_ALIAS(X509_REQ_extension_nid)
 int *
 X509_REQ_get_extension_nids(void)
 {
        return ext_nids;
 }
+LCRYPTO_ALIAS(X509_REQ_get_extension_nids)
 void
 X509_REQ_set_extension_nids(int *nids)
 {
        ext_nids = nids;
 }
+LCRYPTO_ALIAS(X509_REQ_set_extension_nids)
 STACK_OF(X509_EXTENSION) *
 X509_REQ_get_extensions(X509_REQ *req)
@@ -231,6 +238,7 @@ X509_REQ_get_extensions(X509_REQ *req)
        p = ext->value.sequence->data;
        return d2i_X509_EXTENSIONS(NULL, &p, ext->value.sequence->length);
 }
+LCRYPTO_ALIAS(X509_REQ_get_extensions)
 /*
 * Add a STACK_OF extensions to a certificate request: allow alternative OIDs
@@ -254,6 +262,7 @@ X509_REQ_add_extensions_nid(X509_REQ *req, STACK_OF(X509_EXTENSION) *exts,
        return rv;
 }
+LCRYPTO_ALIAS(X509_REQ_add_extensions_nid)
 /* This is the normal usage: use the "official" OID */
 int
@@ -261,6 +270,7 @@ X509_REQ_add_extensions(X509_REQ *req, STACK_OF(X509_EXTENSION) *exts)
 {
        return X509_REQ_add_extensions_nid(req, exts, NID_ext_req);
 }
+LCRYPTO_ALIAS(X509_REQ_add_extensions)
 /* Request attribute functions */
@@ -269,12 +279,14 @@ X509_REQ_get_attr_count(const X509_REQ *req)
 {
        return X509at_get_attr_count(req->req_info->attributes);
 }
+LCRYPTO_ALIAS(X509_REQ_get_attr_count)
 int
 X509_REQ_get_attr_by_NID(const X509_REQ *req, int nid, int lastpos)
 {
        return X509at_get_attr_by_NID(req->req_info->attributes, nid, lastpos);
 }
+LCRYPTO_ALIAS(X509_REQ_get_attr_by_NID)
 int
 X509_REQ_get_attr_by_OBJ(const X509_REQ *req, const ASN1_OBJECT *obj,
@@ -282,18 +294,21 @@ X509_REQ_get_attr_by_OBJ(const X509_REQ *req, const ASN1_OBJECT *obj,
 {
        return X509at_get_attr_by_OBJ(req->req_info->attributes, obj, lastpos);
 }
+LCRYPTO_ALIAS(X509_REQ_get_attr_by_OBJ)
 X509_ATTRIBUTE *
 X509_REQ_get_attr(const X509_REQ *req, int loc)
 {
        return X509at_get_attr(req->req_info->attributes, loc);
 }
+LCRYPTO_ALIAS(X509_REQ_get_attr)
 X509_ATTRIBUTE *
 X509_REQ_delete_attr(X509_REQ *req, int loc)
 {
        return X509at_delete_attr(req->req_info->attributes, loc);
 }
+LCRYPTO_ALIAS(X509_REQ_delete_attr)
 int
 X509_REQ_add1_attr(X509_REQ *req, X509_ATTRIBUTE *attr)
@@ -302,6 +317,7 @@ X509_REQ_add1_attr(X509_REQ *req, X509_ATTRIBUTE *attr)
                return 1;
        return 0;
 }
+LCRYPTO_ALIAS(X509_REQ_add1_attr)
 int
 X509_REQ_add1_attr_by_OBJ(X509_REQ *req, const ASN1_OBJECT *obj, int type,
@@ -312,6 +328,7 @@ X509_REQ_add1_attr_by_OBJ(X509_REQ *req, const ASN1_OBJECT *obj, int type,
                return 1;
        return 0;
 }
+LCRYPTO_ALIAS(X509_REQ_add1_attr_by_OBJ)
 int
 X509_REQ_add1_attr_by_NID(X509_REQ *req, int nid, int type,
@@ -322,6 +339,7 @@ X509_REQ_add1_attr_by_NID(X509_REQ *req, int nid, int type,
                return 1;
        return 0;
 }
+LCRYPTO_ALIAS(X509_REQ_add1_attr_by_NID)
 int
 X509_REQ_add1_attr_by_txt(X509_REQ *req, const char *attrname, int type,
@@ -332,6 +350,7 @@ X509_REQ_add1_attr_by_txt(X509_REQ *req, const char *attrname, int type,
                return 1;
        return 0;
 }
+LCRYPTO_ALIAS(X509_REQ_add1_attr_by_txt)
 int
 i2d_re_X509_REQ_tbs(X509_REQ *req, unsigned char **pp)
@@ -339,3 +358,4 @@ i2d_re_X509_REQ_tbs(X509_REQ *req, unsigned char **pp)
        req->req_info->enc.modified = 1;
        return i2d_X509_REQ_INFO(req->req_info, pp);
 }
+LCRYPTO_ALIAS(i2d_re_X509_REQ_tbs)
diff --git a/src/lib/libcrypto/x509/x509_set.c b/src/lib/libcrypto/x509/x509_set.c
index 5784f2203e..91d6483a3b 100644
--- a/src/lib/libcrypto/x509/x509_set.c
+++ b/src/lib/libcrypto/x509/x509_set.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: x509_set.c,v 1.20 2021/11/01 20:53:08 tb Exp $ */
+/* $OpenBSD: x509_set.c,v 1.21 2022/11/14 17:48:50 beck Exp $ */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
 * All rights reserved.
 *
@@ -70,12 +70,14 @@ X509_get0_extensions(const X509 *x)
 {
        return x->cert_info->extensions;
 }
+LCRYPTO_ALIAS(X509_get0_extensions)
 const X509_ALGOR *
 X509_get0_tbs_sigalg(const X509 *x)
 {
        return x->cert_info->signature;
 }
+LCRYPTO_ALIAS(X509_get0_tbs_sigalg)
 int
 X509_set_version(X509 *x, long version)
@@ -88,12 +90,14 @@ X509_set_version(X509 *x, long version)
        }
        return (ASN1_INTEGER_set(x->cert_info->version, version));
 }
+LCRYPTO_ALIAS(X509_set_version)
 long
 X509_get_version(const X509 *x)
 {
        return ASN1_INTEGER_get(x->cert_info->version);
 }
+LCRYPTO_ALIAS(X509_get_version)
 int
 X509_set_serialNumber(X509 *x, ASN1_INTEGER *serial)
@@ -112,6 +116,7 @@ X509_set_serialNumber(X509 *x, ASN1_INTEGER *serial)
        }
        return (in != NULL);
 }
+LCRYPTO_ALIAS(X509_set_serialNumber)
 int
 X509_set_issuer_name(X509 *x, X509_NAME *name)
@@ -120,6 +125,7 @@ X509_set_issuer_name(X509 *x, X509_NAME *name)
                return (0);
        return (X509_NAME_set(&x->cert_info->issuer, name));
 }
+LCRYPTO_ALIAS(X509_set_issuer_name)
 int
 X509_set_subject_name(X509 *x, X509_NAME *name)
@@ -128,12 +134,14 @@ X509_set_subject_name(X509 *x, X509_NAME *name)
                return (0);
        return (X509_NAME_set(&x->cert_info->subject, name));
 }
+LCRYPTO_ALIAS(X509_set_subject_name)
 const ASN1_TIME *
 X509_get0_notBefore(const X509 *x)
 {
        return X509_getm_notBefore(x);
 }
+LCRYPTO_ALIAS(X509_get0_notBefore)
 ASN1_TIME *
 X509_getm_notBefore(const X509 *x)
@@ -142,6 +150,7 @@ X509_getm_notBefore(const X509 *x)
                return (NULL);
        return x->cert_info->validity->notBefore;
 }
+LCRYPTO_ALIAS(X509_getm_notBefore)
 int
 X509_set_notBefore(X509 *x, const ASN1_TIME *tm)
@@ -160,18 +169,21 @@ X509_set_notBefore(X509 *x, const ASN1_TIME *tm)
        }
        return (in != NULL);
 }
+LCRYPTO_ALIAS(X509_set_notBefore)
 int
 X509_set1_notBefore(X509 *x, const ASN1_TIME *tm)
 {
        return X509_set_notBefore(x, tm);
 }
+LCRYPTO_ALIAS(X509_set1_notBefore)
 const ASN1_TIME *
 X509_get0_notAfter(const X509 *x)
 {
        return X509_getm_notAfter(x);
 }
+LCRYPTO_ALIAS(X509_get0_notAfter)
 ASN1_TIME *
 X509_getm_notAfter(const X509 *x)
@@ -180,6 +192,7 @@ X509_getm_notAfter(const X509 *x)
                return (NULL);
        return x->cert_info->validity->notAfter;
 }
+LCRYPTO_ALIAS(X509_getm_notAfter)
 int
 X509_set_notAfter(X509 *x, const ASN1_TIME *tm)
@@ -198,12 +211,14 @@ X509_set_notAfter(X509 *x, const ASN1_TIME *tm)
        }
        return (in != NULL);
 }
+LCRYPTO_ALIAS(X509_set_notAfter)
 int
 X509_set1_notAfter(X509 *x, const ASN1_TIME *tm)
 {
        return X509_set_notAfter(x, tm);
 }
+LCRYPTO_ALIAS(X509_set1_notAfter)
 int
 X509_set_pubkey(X509 *x, EVP_PKEY *pkey)
@@ -212,15 +227,18 @@ X509_set_pubkey(X509 *x, EVP_PKEY *pkey)
                return (0);
        return (X509_PUBKEY_set(&(x->cert_info->key), pkey));
 }
+LCRYPTO_ALIAS(X509_set_pubkey)
 int
 X509_get_signature_type(const X509 *x)
 {
        return EVP_PKEY_type(OBJ_obj2nid(x->sig_alg->algorithm));
 }
+LCRYPTO_ALIAS(X509_get_signature_type)
 X509_PUBKEY *
 X509_get_X509_PUBKEY(const X509 *x)
 {
        return x->cert_info->key;
 }
+LCRYPTO_ALIAS(X509_get_X509_PUBKEY)
diff --git a/src/lib/libcrypto/x509/x509_skey.c b/src/lib/libcrypto/x509/x509_skey.c
index 58bb66bc05..813a8de199 100644
--- a/src/lib/libcrypto/x509/x509_skey.c
+++ b/src/lib/libcrypto/x509/x509_skey.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: x509_skey.c,v 1.2 2021/11/01 20:53:08 tb Exp $ */
+/* $OpenBSD: x509_skey.c,v 1.3 2022/11/14 17:48:50 beck Exp $ */
 /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
 * project 1999.
 */
@@ -89,6 +89,7 @@ i2s_ASN1_OCTET_STRING(X509V3_EXT_METHOD *method, const ASN1_OCTET_STRING *oct)
 {
        return hex_to_string(oct->data, oct->length);
 }
+LCRYPTO_ALIAS(i2s_ASN1_OCTET_STRING)
 ASN1_OCTET_STRING *
 s2i_ASN1_OCTET_STRING(X509V3_EXT_METHOD *method, X509V3_CTX *ctx,
@@ -111,6 +112,7 @@ s2i_ASN1_OCTET_STRING(X509V3_EXT_METHOD *method, X509V3_CTX *ctx,
        return oct;
 }
+LCRYPTO_ALIAS(s2i_ASN1_OCTET_STRING)
 static ASN1_OCTET_STRING *
 s2i_skey_id(X509V3_EXT_METHOD *method, X509V3_CTX *ctx, char *str)
diff --git a/src/lib/libcrypto/x509/x509_sxnet.c b/src/lib/libcrypto/x509/x509_sxnet.c
index e5e98bcecc..9c66a6b769 100644
--- a/src/lib/libcrypto/x509/x509_sxnet.c
+++ b/src/lib/libcrypto/x509/x509_sxnet.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: x509_sxnet.c,v 1.1 2020/06/04 15:19:32 jsing Exp $ */
+/* $OpenBSD: x509_sxnet.c,v 1.2 2022/11/14 17:48:50 beck Exp $ */
 /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
 * project 1999.
 */
@@ -131,24 +131,28 @@ d2i_SXNETID(SXNETID **a, const unsigned char **in, long len)
        return (SXNETID *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
            &SXNETID_it);
 }
+LCRYPTO_ALIAS(d2i_SXNETID)
 int
 i2d_SXNETID(SXNETID *a, unsigned char **out)
 {
        return ASN1_item_i2d((ASN1_VALUE *)a, out, &SXNETID_it);
 }
+LCRYPTO_ALIAS(i2d_SXNETID)
 SXNETID *
 SXNETID_new(void)
 {
        return (SXNETID *)ASN1_item_new(&SXNETID_it);
 }
+LCRYPTO_ALIAS(SXNETID_new)
 void
 SXNETID_free(SXNETID *a)
 {
        ASN1_item_free((ASN1_VALUE *)a, &SXNETID_it);
 }
+LCRYPTO_ALIAS(SXNETID_free)
 static const ASN1_TEMPLATE SXNET_seq_tt[] = {
        {
@@ -184,24 +188,28 @@ d2i_SXNET(SXNET **a, const unsigned char **in, long len)
        return (SXNET *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
            &SXNET_it);
 }
+LCRYPTO_ALIAS(d2i_SXNET)
 int
 i2d_SXNET(SXNET *a, unsigned char **out)
 {
        return ASN1_item_i2d((ASN1_VALUE *)a, out, &SXNET_it);
 }
+LCRYPTO_ALIAS(i2d_SXNET)
 SXNET *
 SXNET_new(void)
 {
        return (SXNET *)ASN1_item_new(&SXNET_it);
 }
+LCRYPTO_ALIAS(SXNET_new)
 void
 SXNET_free(SXNET *a)
 {
        ASN1_item_free((ASN1_VALUE *)a, &SXNET_it);
 }
+LCRYPTO_ALIAS(SXNET_free)
 static int
 sxnet_i2r(X509V3_EXT_METHOD *method, SXNET *sx, BIO *out, int indent)
@@ -263,6 +271,7 @@ SXNET_add_id_asc(SXNET **psx, const char *zone, const char *user, int userlen)
        }
        return SXNET_add_id_INTEGER(psx, izone, user, userlen);
 }
+LCRYPTO_ALIAS(SXNET_add_id_asc)
 /* Add an id given the zone as an unsigned long */
@@ -280,6 +289,7 @@ SXNET_add_id_ulong(SXNET **psx, unsigned long lzone, const char *user,
        }
        return SXNET_add_id_INTEGER(psx, izone, user, userlen);
 }
+LCRYPTO_ALIAS(SXNET_add_id_ulong)
 /* Add an id given the zone as an ASN1_INTEGER.
 * Note this version uses the passed integer and doesn't make a copy so don't
@@ -335,6 +345,7 @@ err:
        *psx = NULL;
        return 0;
 }
+LCRYPTO_ALIAS(SXNET_add_id_INTEGER)
 ASN1_OCTET_STRING *
 SXNET_get_id_asc(SXNET *sx, const char *zone)
@@ -350,6 +361,7 @@ SXNET_get_id_asc(SXNET *sx, const char *zone)
        ASN1_INTEGER_free(izone);
        return oct;
 }
+LCRYPTO_ALIAS(SXNET_get_id_asc)
 ASN1_OCTET_STRING *
 SXNET_get_id_ulong(SXNET *sx, unsigned long lzone)
@@ -367,6 +379,7 @@ SXNET_get_id_ulong(SXNET *sx, unsigned long lzone)
        ASN1_INTEGER_free(izone);
        return oct;
 }
+LCRYPTO_ALIAS(SXNET_get_id_ulong)
 ASN1_OCTET_STRING *
 SXNET_get_id_INTEGER(SXNET *sx, ASN1_INTEGER *zone)
@@ -381,3 +394,4 @@ SXNET_get_id_INTEGER(SXNET *sx, ASN1_INTEGER *zone)
        }
        return NULL;
 }
+LCRYPTO_ALIAS(SXNET_get_id_INTEGER)
diff --git a/src/lib/libcrypto/x509/x509_trs.c b/src/lib/libcrypto/x509/x509_trs.c
index 23eca4927b..b075d1b6c8 100644
--- a/src/lib/libcrypto/x509/x509_trs.c
+++ b/src/lib/libcrypto/x509/x509_trs.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: x509_trs.c,v 1.27 2022/11/13 18:37:32 beck Exp $ */
+/* $OpenBSD: x509_trs.c,v 1.28 2022/11/14 17:48:50 beck Exp $ */
 /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
 * project 1999.
 */
@@ -109,6 +109,7 @@ int
        default_trust = trust;
        return oldtrust;
 }
+LCRYPTO_ALIAS(X509_TRUST_set_default)
 static int
 X509_check_trust_internal(X509 *x, int id, int flags, int compat)
@@ -140,6 +141,7 @@ X509_check_trust_internal(X509 *x, int id, int flags, int compat)
        pt = X509_TRUST_get0(idx);
        return pt->check_trust(pt, x, flags);
 }
+LCRYPTO_ALIAS(X509_check_trust)
 int
 X509_check_trust(X509 *x, int id, int flags)
@@ -160,6 +162,7 @@ X509_TRUST_get_count(void)
                return X509_TRUST_COUNT;
        return sk_X509_TRUST_num(trtable) + X509_TRUST_COUNT;
 }
+LCRYPTO_ALIAS(X509_TRUST_get_count)
 X509_TRUST *
 X509_TRUST_get0(int idx)
@@ -170,6 +173,7 @@ X509_TRUST_get0(int idx)
                return trstandard + idx;
        return sk_X509_TRUST_value(trtable, idx - X509_TRUST_COUNT);
 }
+LCRYPTO_ALIAS(X509_TRUST_get0)
 int
 X509_TRUST_get_by_id(int id)
@@ -187,6 +191,7 @@ X509_TRUST_get_by_id(int id)
                return -1;
        return idx + X509_TRUST_COUNT;
 }
+LCRYPTO_ALIAS(X509_TRUST_get_by_id)
 int
 X509_TRUST_set(int *t, int trust)
@@ -198,6 +203,7 @@ X509_TRUST_set(int *t, int trust)
        *t = trust;
        return 1;
 }
+LCRYPTO_ALIAS(X509_TRUST_set)
 int
 X509_TRUST_add(int id, int flags, int (*ck)(X509_TRUST *, X509 *, int),
@@ -263,6 +269,7 @@ err:
        X509error(ERR_R_MALLOC_FAILURE);
        return 0;
 }
+LCRYPTO_ALIAS(X509_TRUST_add)
 static void
 trtable_free(X509_TRUST *p)
@@ -282,24 +289,28 @@ X509_TRUST_cleanup(void)
        sk_X509_TRUST_pop_free(trtable, trtable_free);
        trtable = NULL;
 }
+LCRYPTO_ALIAS(X509_TRUST_cleanup)
 int
 X509_TRUST_get_flags(const X509_TRUST *xp)
 {
        return xp->flags;
 }
+LCRYPTO_ALIAS(X509_TRUST_get_flags)
 char *
 X509_TRUST_get0_name(const X509_TRUST *xp)
 {
        return xp->name;
 }
+LCRYPTO_ALIAS(X509_TRUST_get0_name)
 int
 X509_TRUST_get_trust(const X509_TRUST *xp)
 {
        return xp->trust;
 }
+LCRYPTO_ALIAS(X509_TRUST_get_trust)
 static int
 trust_1oidany(X509_TRUST *trust, X509 *x, int flags)
diff --git a/src/lib/libcrypto/x509/x509_txt.c b/src/lib/libcrypto/x509/x509_txt.c
index 2dfadf6ba6..129757494c 100644
--- a/src/lib/libcrypto/x509/x509_txt.c
+++ b/src/lib/libcrypto/x509/x509_txt.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: x509_txt.c,v 1.20 2022/07/05 20:31:46 tb Exp $ */
+/* $OpenBSD: x509_txt.c,v 1.21 2022/11/14 17:48:50 beck Exp $ */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
 * All rights reserved.
 *
@@ -203,3 +203,4 @@ X509_verify_cert_error_string(long n)
                return(buf);
        }
 }
+LCRYPTO_ALIAS(X509_verify_cert_error_string)
diff --git a/src/lib/libcrypto/x509/x509_utl.c b/src/lib/libcrypto/x509/x509_utl.c
index 47b25fe6c4..525939d4ca 100644
--- a/src/lib/libcrypto/x509/x509_utl.c
+++ b/src/lib/libcrypto/x509/x509_utl.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: x509_utl.c,v 1.3 2022/05/20 07:58:54 tb Exp $ */
+/* $OpenBSD: x509_utl.c,v 1.4 2022/11/14 17:48:50 beck Exp $ */
 /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
 * project.
 */
@@ -117,6 +117,7 @@ X509V3_add_value(const char *name, const char *value,
        }
        return 0;
 }
+LCRYPTO_ALIAS(X509V3_add_value)
 int
 X509V3_add_value_uchar(const char *name, const unsigned char *value,
@@ -124,6 +125,7 @@ X509V3_add_value_uchar(const char *name, const unsigned char *value,
 {
        return X509V3_add_value(name, (const char *)value, extlist);
 }
+LCRYPTO_ALIAS(X509V3_add_value_uchar)
 /* Free function for STACK_OF(CONF_VALUE) */
@@ -137,6 +139,7 @@ X509V3_conf_free(CONF_VALUE *conf)
        free(conf->section);
        free(conf);
 }
+LCRYPTO_ALIAS(X509V3_conf_free)
 int
 X509V3_add_value_bool(const char *name, int asn1_bool,
@@ -146,6 +149,7 @@ X509V3_add_value_bool(const char *name, int asn1_bool,
                return X509V3_add_value(name, "TRUE", extlist);
        return X509V3_add_value(name, "FALSE", extlist);
 }
+LCRYPTO_ALIAS(X509V3_add_value_bool)
 int
 X509V3_add_value_bool_nf(const char *name, int asn1_bool,
@@ -155,6 +159,7 @@ X509V3_add_value_bool_nf(const char *name, int asn1_bool,
                return X509V3_add_value(name, "TRUE", extlist);
        return 1;
 }
+LCRYPTO_ALIAS(X509V3_add_value_bool_nf)
 char *
 bn_to_string(const BIGNUM *bn)
@@ -197,6 +202,7 @@ i2s_ASN1_ENUMERATED(X509V3_EXT_METHOD *method, const ASN1_ENUMERATED *a)
        BN_free(bntmp);
        return strtmp;
 }
+LCRYPTO_ALIAS(i2s_ASN1_ENUMERATED)
 char *
 i2s_ASN1_INTEGER(X509V3_EXT_METHOD *method, const ASN1_INTEGER *a)
@@ -212,6 +218,7 @@ i2s_ASN1_INTEGER(X509V3_EXT_METHOD *method, const ASN1_INTEGER *a)
        BN_free(bntmp);
        return strtmp;
 }
+LCRYPTO_ALIAS(i2s_ASN1_INTEGER)
 ASN1_INTEGER *
 s2i_ASN1_INTEGER(X509V3_EXT_METHOD *method, const char *value)
@@ -262,6 +269,7 @@ s2i_ASN1_INTEGER(X509V3_EXT_METHOD *method, const char *value)
                aint->type |= V_ASN1_NEG;
        return aint;
 }
+LCRYPTO_ALIAS(s2i_ASN1_INTEGER)
 int
 X509V3_add_value_int(const char *name, const ASN1_INTEGER *aint,
@@ -278,6 +286,7 @@ X509V3_add_value_int(const char *name, const ASN1_INTEGER *aint,
        free(strtmp);
        return ret;
 }
+LCRYPTO_ALIAS(X509V3_add_value_int)
 int
 X509V3_get_value_bool(const CONF_VALUE *value, int *asn1_bool)
@@ -303,6 +312,7 @@ X509V3_get_value_bool(const CONF_VALUE *value, int *asn1_bool)
        X509V3_conf_err(value);
        return 0;
 }
+LCRYPTO_ALIAS(X509V3_get_value_bool)
 int
 X509V3_get_value_int(const CONF_VALUE *value, ASN1_INTEGER **aint)
@@ -316,6 +326,7 @@ X509V3_get_value_int(const CONF_VALUE *value, ASN1_INTEGER **aint)
        *aint = itmp;
        return 1;
 }
+LCRYPTO_ALIAS(X509V3_get_value_int)
 #define HDR_NAME        1
 #define HDR_VALUE       2
@@ -407,6 +418,7 @@ X509V3_parse_list(const char *line)
        return NULL;
 }
+LCRYPTO_ALIAS(X509V3_parse_list)
 /* Delete leading and trailing spaces from a string */
 static char *
@@ -458,6 +470,7 @@ hex_to_string(const unsigned char *buffer, long len)
        q[-1] = 0;
        return tmp;
 }
+LCRYPTO_ALIAS(hex_to_string)
 /* Give a string of hex digits convert to
 * a buffer
@@ -519,6 +532,7 @@ string_to_hex(const char *str, long *len)
        X509V3error(X509V3_R_ILLEGAL_HEX_DIGIT);
        return NULL;
 }
+LCRYPTO_ALIAS(string_to_hex)
 /* V2I name comparison function: returns zero if 'name' matches
 * cmp or cmp.*
@@ -556,6 +570,7 @@ X509_get1_email(X509 *x)
        sk_GENERAL_NAME_pop_free(gens, GENERAL_NAME_free);
        return ret;
 }
+LCRYPTO_ALIAS(X509_get1_email)
 STACK_OF(OPENSSL_STRING) *
 X509_get1_ocsp(X509 *x)
@@ -580,6 +595,7 @@ X509_get1_ocsp(X509 *x)
        AUTHORITY_INFO_ACCESS_free(info);
        return ret;
 }
+LCRYPTO_ALIAS(X509_get1_ocsp)
 STACK_OF(OPENSSL_STRING) *
 X509_REQ_get1_email(X509_REQ *x)
@@ -595,6 +611,7 @@ X509_REQ_get1_email(X509_REQ *x)
        sk_X509_EXTENSION_pop_free(exts, X509_EXTENSION_free);
        return ret;
 }
+LCRYPTO_ALIAS(X509_REQ_get1_email)
 static STACK_OF(OPENSSL_STRING) *
@@ -664,6 +681,7 @@ X509_email_free(STACK_OF(OPENSSL_STRING) *sk)
 {
        sk_OPENSSL_STRING_pop_free(sk, str_free);
 }
+LCRYPTO_ALIAS(X509_email_free)
 typedef int (*equal_fn)(const unsigned char *pattern, size_t pattern_len,
    const unsigned char *subject, size_t subject_len, unsigned int flags);
@@ -1065,6 +1083,7 @@ X509_check_host(X509 *x, const char *chk, size_t chklen, unsigned int flags,
                return -2;
        return do_x509_check(x, chk, chklen, flags, GEN_DNS, peername);
 }
+LCRYPTO_ALIAS(X509_check_host)
 int
 X509_check_email(X509 *x, const char *chk, size_t chklen, unsigned int flags)
@@ -1077,6 +1096,7 @@ X509_check_email(X509 *x, const char *chk, size_t chklen, unsigned int flags)
                return -2;
        return do_x509_check(x, chk, chklen, flags, GEN_EMAIL, NULL);
 }
+LCRYPTO_ALIAS(X509_check_email)
 int
 X509_check_ip(X509 *x, const unsigned char *chk, size_t chklen,
@@ -1086,6 +1106,7 @@ X509_check_ip(X509 *x, const unsigned char *chk, size_t chklen,
                return -2;
        return do_x509_check(x, (char *)chk, chklen, flags, GEN_IPADD, NULL);
 }
+LCRYPTO_ALIAS(X509_check_ip)
 int
 X509_check_ip_asc(X509 *x, const char *ipasc, unsigned int flags)
@@ -1100,6 +1121,7 @@ X509_check_ip_asc(X509 *x, const char *ipasc, unsigned int flags)
                return -2;
        return do_x509_check(x, (char *)ipout, iplen, flags, GEN_IPADD, NULL);
 }
+LCRYPTO_ALIAS(X509_check_ip_asc)
 /* Convert IP addresses both IPv4 and IPv6 into an
 * OCTET STRING compatible with RFC3280.
@@ -1128,6 +1150,7 @@ a2i_IPADDRESS(const char *ipasc)
        }
        return ret;
 }
+LCRYPTO_ALIAS(a2i_IPADDRESS)
 ASN1_OCTET_STRING *
 a2i_IPADDRESS_NC(const char *ipasc)
@@ -1173,6 +1196,7 @@ a2i_IPADDRESS_NC(const char *ipasc)
                ASN1_OCTET_STRING_free(ret);
        return NULL;
 }
+LCRYPTO_ALIAS(a2i_IPADDRESS_NC)
 int
@@ -1190,6 +1214,7 @@ a2i_ipadd(unsigned char *ipout, const char *ipasc)
                return 4;
        }
 }
+LCRYPTO_ALIAS(a2i_ipadd)
 static int
 ipv4_from_asc(unsigned char *v4, const char *in)
@@ -1386,3 +1411,4 @@ X509V3_NAME_from_section(X509_NAME *nm, STACK_OF(CONF_VALUE)*dn_sk,
        }
        return 1;
 }
+LCRYPTO_ALIAS(X509V3_NAME_from_section)
diff --git a/src/lib/libcrypto/x509/x509_v3.c b/src/lib/libcrypto/x509/x509_v3.c
index 9aefb8d99d..4f66524f51 100644
--- a/src/lib/libcrypto/x509/x509_v3.c
+++ b/src/lib/libcrypto/x509/x509_v3.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: x509_v3.c,v 1.18 2021/11/01 20:53:08 tb Exp $ */
+/* $OpenBSD: x509_v3.c,v 1.19 2022/11/14 17:48:50 beck Exp $ */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
 * All rights reserved.
 *
@@ -75,6 +75,7 @@ X509v3_get_ext_count(const STACK_OF(X509_EXTENSION) *x)
                return (0);
        return (sk_X509_EXTENSION_num(x));
 }
+LCRYPTO_ALIAS(X509v3_get_ext_count)
 int
 X509v3_get_ext_by_NID(const STACK_OF(X509_EXTENSION) *x, int nid, int lastpos)
@@ -86,6 +87,7 @@ X509v3_get_ext_by_NID(const STACK_OF(X509_EXTENSION) *x, int nid, int lastpos)
                return (-2);
        return (X509v3_get_ext_by_OBJ(x, obj, lastpos));
 }
+LCRYPTO_ALIAS(X509v3_get_ext_by_NID)
 int
 X509v3_get_ext_by_OBJ(const STACK_OF(X509_EXTENSION) *sk,
@@ -107,6 +109,7 @@ X509v3_get_ext_by_OBJ(const STACK_OF(X509_EXTENSION) *sk,
        }
        return (-1);
 }
+LCRYPTO_ALIAS(X509v3_get_ext_by_OBJ)
 int
 X509v3_get_ext_by_critical(const STACK_OF(X509_EXTENSION) *sk, int crit,
@@ -129,6 +132,7 @@ X509v3_get_ext_by_critical(const STACK_OF(X509_EXTENSION) *sk, int crit,
        }
        return (-1);
 }
+LCRYPTO_ALIAS(X509v3_get_ext_by_critical)
 X509_EXTENSION *
 X509v3_get_ext(const STACK_OF(X509_EXTENSION) *x, int loc)
@@ -138,6 +142,7 @@ X509v3_get_ext(const STACK_OF(X509_EXTENSION) *x, int loc)
        else
                return sk_X509_EXTENSION_value(x, loc);
 }
+LCRYPTO_ALIAS(X509v3_get_ext)
 X509_EXTENSION *
 X509v3_delete_ext(STACK_OF(X509_EXTENSION) *x, int loc)
@@ -149,6 +154,7 @@ X509v3_delete_ext(STACK_OF(X509_EXTENSION) *x, int loc)
        ret = sk_X509_EXTENSION_delete(x, loc);
        return (ret);
 }
+LCRYPTO_ALIAS(X509v3_delete_ext)
 STACK_OF(X509_EXTENSION) *
 X509v3_add_ext(STACK_OF(X509_EXTENSION) **x, X509_EXTENSION *ex, int loc)
@@ -191,6 +197,7 @@ err2:
                sk_X509_EXTENSION_free(sk);
        return (NULL);
 }
+LCRYPTO_ALIAS(X509v3_add_ext)
 X509_EXTENSION *
 X509_EXTENSION_create_by_NID(X509_EXTENSION **ex, int nid, int crit,
@@ -209,6 +216,7 @@ X509_EXTENSION_create_by_NID(X509_EXTENSION **ex, int nid, int crit,
                ASN1_OBJECT_free(obj);
        return (ret);
 }
+LCRYPTO_ALIAS(X509_EXTENSION_create_by_NID)
 X509_EXTENSION *
 X509_EXTENSION_create_by_OBJ(X509_EXTENSION **ex, const ASN1_OBJECT *obj,
@@ -240,6 +248,7 @@ err:
                X509_EXTENSION_free(ret);
        return (NULL);
 }
+LCRYPTO_ALIAS(X509_EXTENSION_create_by_OBJ)
 int
 X509_EXTENSION_set_object(X509_EXTENSION *ex, const ASN1_OBJECT *obj)
@@ -250,6 +259,7 @@ X509_EXTENSION_set_object(X509_EXTENSION *ex, const ASN1_OBJECT *obj)
        ex->object = OBJ_dup(obj);
        return ex->object != NULL;
 }
+LCRYPTO_ALIAS(X509_EXTENSION_set_object)
 int
 X509_EXTENSION_set_critical(X509_EXTENSION *ex, int crit)
@@ -259,6 +269,7 @@ X509_EXTENSION_set_critical(X509_EXTENSION *ex, int crit)
        ex->critical = (crit) ? 0xFF : -1;
        return (1);
 }
+LCRYPTO_ALIAS(X509_EXTENSION_set_critical)
 int
 X509_EXTENSION_set_data(X509_EXTENSION *ex, ASN1_OCTET_STRING *data)
@@ -272,6 +283,7 @@ X509_EXTENSION_set_data(X509_EXTENSION *ex, ASN1_OCTET_STRING *data)
                return (0);
        return (1);
 }
+LCRYPTO_ALIAS(X509_EXTENSION_set_data)
 ASN1_OBJECT *
 X509_EXTENSION_get_object(X509_EXTENSION *ex)
@@ -280,6 +292,7 @@ X509_EXTENSION_get_object(X509_EXTENSION *ex)
                return (NULL);
        return (ex->object);
 }
+LCRYPTO_ALIAS(X509_EXTENSION_get_object)
 ASN1_OCTET_STRING *
 X509_EXTENSION_get_data(X509_EXTENSION *ex)
@@ -288,6 +301,7 @@ X509_EXTENSION_get_data(X509_EXTENSION *ex)
                return (NULL);
        return (ex->value);
 }
+LCRYPTO_ALIAS(X509_EXTENSION_get_data)
 int
 X509_EXTENSION_get_critical(const X509_EXTENSION *ex)
@@ -298,3 +312,4 @@ X509_EXTENSION_get_critical(const X509_EXTENSION *ex)
                return 1;
        return 0;
 }
+LCRYPTO_ALIAS(X509_EXTENSION_get_critical)
diff --git a/src/lib/libcrypto/x509/x509_vfy.c b/src/lib/libcrypto/x509/x509_vfy.c
index 11bf3d9292..09c0b8105e 100644
--- a/src/lib/libcrypto/x509/x509_vfy.c
+++ b/src/lib/libcrypto/x509/x509_vfy.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: x509_vfy.c,v 1.104 2022/11/13 18:37:32 beck Exp $ */
+/* $OpenBSD: x509_vfy.c,v 1.105 2022/11/14 17:48:50 beck Exp $ */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
 * All rights reserved.
 *
@@ -668,6 +668,7 @@ X509_verify_cert(X509_STORE_CTX *ctx)
        /* if we succeed we have a chain in ctx->chain */
        return (chain_count > 0 && ctx->chain != NULL);
 }
+LCRYPTO_ALIAS(X509_verify_cert)
 /* Given a STACK_OF(X509) find the issuer of cert (if any)
 */
@@ -2062,6 +2063,7 @@ X509_cmp_current_time(const ASN1_TIME *ctm)
 {
        return X509_cmp_time(ctm, NULL);
 }
+LCRYPTO_ALIAS(X509_cmp_current_time)
 /*
 * Compare a possibly unvalidated ASN1_TIME string against a time_t
@@ -2101,6 +2103,7 @@ X509_cmp_time(const ASN1_TIME *ctm, time_t *cmp_time)
 {
        return X509_cmp_time_internal(ctm, cmp_time, 0);
 }
+LCRYPTO_ALIAS(X509_cmp_time)
 ASN1_TIME *
@@ -2108,12 +2111,14 @@ X509_gmtime_adj(ASN1_TIME *s, long adj)
 {
        return X509_time_adj(s, adj, NULL);
 }
+LCRYPTO_ALIAS(X509_gmtime_adj)
 ASN1_TIME *
 X509_time_adj(ASN1_TIME *s, long offset_sec, time_t *in_time)
 {
        return X509_time_adj_ex(s, 0, offset_sec, in_time);
 }
+LCRYPTO_ALIAS(X509_time_adj)
 ASN1_TIME *
 X509_time_adj_ex(ASN1_TIME *s, int offset_day, long offset_sec, time_t *in_time)
@@ -2126,6 +2131,7 @@ X509_time_adj_ex(ASN1_TIME *s, int offset_day, long offset_sec, time_t *in_time)
        return ASN1_TIME_adj(s, t, offset_day, offset_sec);
 }
+LCRYPTO_ALIAS(X509_time_adj_ex)
 int
 X509_get_pubkey_parameters(EVP_PKEY *pkey, STACK_OF(X509) *chain)
@@ -2165,6 +2171,7 @@ X509_get_pubkey_parameters(EVP_PKEY *pkey, STACK_OF(X509) *chain)
                        return 0;
        return 1;
 }
+LCRYPTO_ALIAS(X509_get_pubkey_parameters)
 int
 X509_STORE_CTX_get_ex_new_index(long argl, void *argp, CRYPTO_EX_new *new_func,
@@ -2175,66 +2182,77 @@ X509_STORE_CTX_get_ex_new_index(long argl, void *argp, CRYPTO_EX_new *new_func,
        return CRYPTO_get_ex_new_index(CRYPTO_EX_INDEX_X509_STORE_CTX,
            argl, argp, new_func, dup_func, free_func);
 }
+LCRYPTO_ALIAS(X509_STORE_CTX_get_ex_new_index)
 int
 X509_STORE_CTX_set_ex_data(X509_STORE_CTX *ctx, int idx, void *data)
 {
        return CRYPTO_set_ex_data(&ctx->ex_data, idx, data);
 }
+LCRYPTO_ALIAS(X509_STORE_CTX_set_ex_data)
 void *
 X509_STORE_CTX_get_ex_data(X509_STORE_CTX *ctx, int idx)
 {
        return CRYPTO_get_ex_data(&ctx->ex_data, idx);
 }
+LCRYPTO_ALIAS(X509_STORE_CTX_get_ex_data)
 int
 X509_STORE_CTX_get_error(X509_STORE_CTX *ctx)
 {
        return ctx->error;
 }
+LCRYPTO_ALIAS(X509_STORE_CTX_get_error)
 void
 X509_STORE_CTX_set_error(X509_STORE_CTX *ctx, int err)
 {
        ctx->error = err;
 }
+LCRYPTO_ALIAS(X509_STORE_CTX_set_error)
 int
 X509_STORE_CTX_get_error_depth(X509_STORE_CTX *ctx)
 {
        return ctx->error_depth;
 }
+LCRYPTO_ALIAS(X509_STORE_CTX_get_error_depth)
 void
 X509_STORE_CTX_set_error_depth(X509_STORE_CTX *ctx, int depth)
 {
        ctx->error_depth = depth;
 }
+LCRYPTO_ALIAS(X509_STORE_CTX_set_error_depth)
 X509 *
 X509_STORE_CTX_get_current_cert(X509_STORE_CTX *ctx)
 {
        return ctx->current_cert;
 }
+LCRYPTO_ALIAS(X509_STORE_CTX_get_current_cert)
 void
 X509_STORE_CTX_set_current_cert(X509_STORE_CTX *ctx, X509 *x)
 {
        ctx->current_cert = x;
 }
+LCRYPTO_ALIAS(X509_STORE_CTX_set_current_cert)
 STACK_OF(X509) *
 X509_STORE_CTX_get_chain(X509_STORE_CTX *ctx)
 {
        return ctx->chain;
 }
+LCRYPTO_ALIAS(X509_STORE_CTX_get_chain)
 STACK_OF(X509) *
 X509_STORE_CTX_get0_chain(X509_STORE_CTX *xs)
 {
        return xs->chain;
 }
+LCRYPTO_ALIAS(X509_STORE_CTX_get0_chain)
 STACK_OF(X509) *
 X509_STORE_CTX_get1_chain(X509_STORE_CTX *ctx)
@@ -2251,60 +2269,70 @@ X509_STORE_CTX_get1_chain(X509_STORE_CTX *ctx)
        }
        return chain;
 }
+LCRYPTO_ALIAS(X509_STORE_CTX_get1_chain)
 X509 *
 X509_STORE_CTX_get0_current_issuer(X509_STORE_CTX *ctx)
 {
        return ctx->current_issuer;
 }
+LCRYPTO_ALIAS(X509_STORE_CTX_get0_current_issuer)
 X509_CRL *
 X509_STORE_CTX_get0_current_crl(X509_STORE_CTX *ctx)
 {
        return ctx->current_crl;
 }
+LCRYPTO_ALIAS(X509_STORE_CTX_get0_current_crl)
 X509_STORE_CTX *
 X509_STORE_CTX_get0_parent_ctx(X509_STORE_CTX *ctx)
 {
        return ctx->parent;
 }
+LCRYPTO_ALIAS(X509_STORE_CTX_get0_parent_ctx)
 X509_STORE *
 X509_STORE_CTX_get0_store(X509_STORE_CTX *xs)
 {
        return xs->store;
 }
+LCRYPTO_ALIAS(X509_STORE_CTX_get0_store)
 void
 X509_STORE_CTX_set_cert(X509_STORE_CTX *ctx, X509 *x)
 {
        ctx->cert = x;
 }
+LCRYPTO_ALIAS(X509_STORE_CTX_set_cert)
 void
 X509_STORE_CTX_set_chain(X509_STORE_CTX *ctx, STACK_OF(X509) *sk)
 {
        ctx->untrusted = sk;
 }
+LCRYPTO_ALIAS(X509_STORE_CTX_set_chain)
 void
 X509_STORE_CTX_set0_crls(X509_STORE_CTX *ctx, STACK_OF(X509_CRL) *sk)
 {
        ctx->crls = sk;
 }
+LCRYPTO_ALIAS(X509_STORE_CTX_set0_crls)
 int
 X509_STORE_CTX_set_purpose(X509_STORE_CTX *ctx, int purpose)
 {
        return X509_STORE_CTX_purpose_inherit(ctx, 0, purpose, 0);
 }
+LCRYPTO_ALIAS(X509_STORE_CTX_set_purpose)
 int
 X509_STORE_CTX_set_trust(X509_STORE_CTX *ctx, int trust)
 {
        return X509_STORE_CTX_purpose_inherit(ctx, 0, 0, trust);
 }
+LCRYPTO_ALIAS(X509_STORE_CTX_set_trust)
 /* This function is used to set the X509_STORE_CTX purpose and trust
 * values. This is intended to be used when another structure has its
@@ -2360,6 +2388,7 @@ X509_STORE_CTX_purpose_inherit(X509_STORE_CTX *ctx, int def_purpose,
                ctx->param->trust = trust;
        return 1;
 }
+LCRYPTO_ALIAS(X509_STORE_CTX_purpose_inherit)
 X509_STORE_CTX *
 X509_STORE_CTX_new(void)
@@ -2373,6 +2402,7 @@ X509_STORE_CTX_new(void)
        }
        return ctx;
 }
+LCRYPTO_ALIAS(X509_STORE_CTX_new)
 void
 X509_STORE_CTX_free(X509_STORE_CTX *ctx)
@@ -2383,6 +2413,7 @@ X509_STORE_CTX_free(X509_STORE_CTX *ctx)
        X509_STORE_CTX_cleanup(ctx);
        free(ctx);
 }
+LCRYPTO_ALIAS(X509_STORE_CTX_free)
 int
 X509_STORE_CTX_init(X509_STORE_CTX *ctx, X509_STORE *store, X509 *x509,
@@ -2504,6 +2535,7 @@ X509_STORE_CTX_init(X509_STORE_CTX *ctx, X509_STORE *store, X509 *x509,
        }
        return 1;
 }
+LCRYPTO_ALIAS(X509_STORE_CTX_init)
 /* Set alternative lookup method: just a STACK of trusted certificates.
 * This avoids X509_STORE nastiness where it isn't needed.
@@ -2515,12 +2547,14 @@ X509_STORE_CTX_trusted_stack(X509_STORE_CTX *ctx, STACK_OF(X509) *sk)
        ctx->other_ctx = sk;
        ctx->get_issuer = get_issuer_sk;
 }
+LCRYPTO_ALIAS(X509_STORE_CTX_trusted_stack)
 void
 X509_STORE_CTX_set0_trusted_stack(X509_STORE_CTX *ctx, STACK_OF(X509) *sk)
 {
        X509_STORE_CTX_trusted_stack(ctx, sk);
 }
+LCRYPTO_ALIAS(X509_STORE_CTX_set0_trusted_stack)
 void
 X509_STORE_CTX_cleanup(X509_STORE_CTX *ctx)
@@ -2544,30 +2578,35 @@ X509_STORE_CTX_cleanup(X509_STORE_CTX *ctx)
            ctx, &(ctx->ex_data));
        memset(&ctx->ex_data, 0, sizeof(CRYPTO_EX_DATA));
 }
+LCRYPTO_ALIAS(X509_STORE_CTX_cleanup)
 void
 X509_STORE_CTX_set_depth(X509_STORE_CTX *ctx, int depth)
 {
        X509_VERIFY_PARAM_set_depth(ctx->param, depth);
 }
+LCRYPTO_ALIAS(X509_STORE_CTX_set_depth)
 void
 X509_STORE_CTX_set_flags(X509_STORE_CTX *ctx, unsigned long flags)
 {
        X509_VERIFY_PARAM_set_flags(ctx->param, flags);
 }
+LCRYPTO_ALIAS(X509_STORE_CTX_set_flags)
 void
 X509_STORE_CTX_set_time(X509_STORE_CTX *ctx, unsigned long flags, time_t t)
 {
        X509_VERIFY_PARAM_set_time(ctx->param, t);
 }
+LCRYPTO_ALIAS(X509_STORE_CTX_set_time)
 int
 (*X509_STORE_CTX_get_verify_cb(X509_STORE_CTX *ctx))(int, X509_STORE_CTX *)
 {
        return ctx->verify_cb;
 }
+LCRYPTO_ALIAS(X509_STORE_CTX_get_verify_cb)
 void
 X509_STORE_CTX_set_verify_cb(X509_STORE_CTX *ctx,
@@ -2575,36 +2614,42 @@ X509_STORE_CTX_set_verify_cb(X509_STORE_CTX *ctx,
 {
        ctx->verify_cb = verify_cb;
 }
+LCRYPTO_ALIAS(X509_STORE_CTX_set_verify_cb)
 int
 (*X509_STORE_CTX_get_verify(X509_STORE_CTX *ctx))(X509_STORE_CTX *)
 {
        return ctx->verify;
 }
+LCRYPTO_ALIAS(X509_STORE_CTX_get_verify)
 void
 X509_STORE_CTX_set_verify(X509_STORE_CTX *ctx, int (*verify)(X509_STORE_CTX *))
 {
        ctx->verify = verify;
 }
+LCRYPTO_ALIAS(X509_STORE_CTX_set_verify)
 X509 *
 X509_STORE_CTX_get0_cert(X509_STORE_CTX *ctx)
 {
        return ctx->cert;
 }
+LCRYPTO_ALIAS(X509_STORE_CTX_get0_cert)
 STACK_OF(X509) *
 X509_STORE_CTX_get0_untrusted(X509_STORE_CTX *ctx)
 {
        return ctx->untrusted;
 }
+LCRYPTO_ALIAS(X509_STORE_CTX_get0_untrusted)
 void
 X509_STORE_CTX_set0_untrusted(X509_STORE_CTX *ctx, STACK_OF(X509) *sk)
 {
        ctx->untrusted = sk;
 }
+LCRYPTO_ALIAS(X509_STORE_CTX_set0_untrusted)
 void
 X509_STORE_CTX_set0_verified_chain(X509_STORE_CTX *ctx, STACK_OF(X509) *sk)
@@ -2612,24 +2657,28 @@ X509_STORE_CTX_set0_verified_chain(X509_STORE_CTX *ctx, STACK_OF(X509) *sk)
        sk_X509_pop_free(ctx->chain, X509_free);
        ctx->chain = sk;
 }
+LCRYPTO_ALIAS(X509_STORE_CTX_set0_verified_chain)
 X509_POLICY_TREE *
 X509_STORE_CTX_get0_policy_tree(X509_STORE_CTX *ctx)
 {
        return ctx->tree;
 }
+LCRYPTO_ALIAS(X509_STORE_CTX_get0_policy_tree)
 int
 X509_STORE_CTX_get_explicit_policy(X509_STORE_CTX *ctx)
 {
        return ctx->explicit_policy;
 }
+LCRYPTO_ALIAS(X509_STORE_CTX_get_explicit_policy)
 int
 X509_STORE_CTX_get_num_untrusted(X509_STORE_CTX *ctx)
 {
        return ctx->num_untrusted;
 }
+LCRYPTO_ALIAS(X509_STORE_CTX_get_num_untrusted)
 int
 X509_STORE_CTX_set_default(X509_STORE_CTX *ctx, const char *name)
@@ -2640,12 +2689,14 @@ X509_STORE_CTX_set_default(X509_STORE_CTX *ctx, const char *name)
                return 0;
        return X509_VERIFY_PARAM_inherit(ctx->param, param);
 }
+LCRYPTO_ALIAS(X509_STORE_CTX_set_default)
 X509_VERIFY_PARAM *
 X509_STORE_CTX_get0_param(X509_STORE_CTX *ctx)
 {
        return ctx->param;
 }
+LCRYPTO_ALIAS(X509_STORE_CTX_get0_param)
 void
 X509_STORE_CTX_set0_param(X509_STORE_CTX *ctx, X509_VERIFY_PARAM *param)
@@ -2654,6 +2705,7 @@ X509_STORE_CTX_set0_param(X509_STORE_CTX *ctx, X509_VERIFY_PARAM *param)
                X509_VERIFY_PARAM_free(ctx->param);
        ctx->param = param;
 }
+LCRYPTO_ALIAS(X509_STORE_CTX_set0_param)
 /*
 * Check if |bits| are adequate for |security level|.
diff --git a/src/lib/libcrypto/x509/x509_vpm.c b/src/lib/libcrypto/x509/x509_vpm.c
index e14d7a36fd..56e2c34127 100644
--- a/src/lib/libcrypto/x509/x509_vpm.c
+++ b/src/lib/libcrypto/x509/x509_vpm.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: x509_vpm.c,v 1.30 2022/07/04 12:17:32 tb Exp $ */
+/* $OpenBSD: x509_vpm.c,v 1.31 2022/11/14 17:48:50 beck Exp $ */
 /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
 * project 2004.
 */
@@ -218,6 +218,7 @@ X509_VERIFY_PARAM_new(void)
        x509_verify_param_zero(param);
        return param;
 }
+LCRYPTO_ALIAS(X509_VERIFY_PARAM_new)
 void
 X509_VERIFY_PARAM_free(X509_VERIFY_PARAM *param)
@@ -228,6 +229,7 @@ X509_VERIFY_PARAM_free(X509_VERIFY_PARAM *param)
        free(param->id);
        free(param);
 }
+LCRYPTO_ALIAS(X509_VERIFY_PARAM_free)
 /*
 * This function determines how parameters are "inherited" from one structure
@@ -356,6 +358,7 @@ X509_VERIFY_PARAM_inherit(X509_VERIFY_PARAM *dest, const X509_VERIFY_PARAM *src)
        return 1;
 }
+LCRYPTO_ALIAS(X509_VERIFY_PARAM_inherit)
 int
 X509_VERIFY_PARAM_set1(X509_VERIFY_PARAM *to, const X509_VERIFY_PARAM *from)
@@ -368,6 +371,7 @@ X509_VERIFY_PARAM_set1(X509_VERIFY_PARAM *to, const X509_VERIFY_PARAM *from)
        to->inh_flags = save_flags;
        return ret;
 }
+LCRYPTO_ALIAS(X509_VERIFY_PARAM_set1)
 static int
 x509_param_set1_internal(char **pdest, size_t *pdestlen,  const char *src,
@@ -412,6 +416,7 @@ X509_VERIFY_PARAM_set1_name(X509_VERIFY_PARAM *param, const char *name)
                return 1;
        return 0;
 }
+LCRYPTO_ALIAS(X509_VERIFY_PARAM_set1_name)
 int
 X509_VERIFY_PARAM_set_flags(X509_VERIFY_PARAM *param, unsigned long flags)
@@ -421,6 +426,7 @@ X509_VERIFY_PARAM_set_flags(X509_VERIFY_PARAM *param, unsigned long flags)
                param->flags |= X509_V_FLAG_POLICY_CHECK;
        return 1;
 }
+LCRYPTO_ALIAS(X509_VERIFY_PARAM_set_flags)
 int
 X509_VERIFY_PARAM_clear_flags(X509_VERIFY_PARAM *param, unsigned long flags)
@@ -428,42 +434,49 @@ X509_VERIFY_PARAM_clear_flags(X509_VERIFY_PARAM *param, unsigned long flags)
        param->flags &= ~flags;
        return 1;
 }
+LCRYPTO_ALIAS(X509_VERIFY_PARAM_clear_flags)
 unsigned long
 X509_VERIFY_PARAM_get_flags(X509_VERIFY_PARAM *param)
 {
        return param->flags;
 }
+LCRYPTO_ALIAS(X509_VERIFY_PARAM_get_flags)
 int
 X509_VERIFY_PARAM_set_purpose(X509_VERIFY_PARAM *param, int purpose)
 {
        return X509_PURPOSE_set(&param->purpose, purpose);
 }
+LCRYPTO_ALIAS(X509_VERIFY_PARAM_set_purpose)
 int
 X509_VERIFY_PARAM_set_trust(X509_VERIFY_PARAM *param, int trust)
 {
        return X509_TRUST_set(&param->trust, trust);
 }
+LCRYPTO_ALIAS(X509_VERIFY_PARAM_set_trust)
 void
 X509_VERIFY_PARAM_set_depth(X509_VERIFY_PARAM *param, int depth)
 {
        param->depth = depth;
 }
+LCRYPTO_ALIAS(X509_VERIFY_PARAM_set_depth)
 void
 X509_VERIFY_PARAM_set_auth_level(X509_VERIFY_PARAM *param, int auth_level)
 {
        param->security_level = auth_level;
 }
+LCRYPTO_ALIAS(X509_VERIFY_PARAM_set_auth_level)
 time_t
 X509_VERIFY_PARAM_get_time(const X509_VERIFY_PARAM *param)
 {
        return param->check_time;
 }
+LCRYPTO_ALIAS(X509_VERIFY_PARAM_get_time)
 void
 X509_VERIFY_PARAM_set_time(X509_VERIFY_PARAM *param, time_t t)
@@ -471,6 +484,7 @@ X509_VERIFY_PARAM_set_time(X509_VERIFY_PARAM *param, time_t t)
        param->check_time = t;
        param->flags |= X509_V_FLAG_USE_CHECK_TIME;
 }
+LCRYPTO_ALIAS(X509_VERIFY_PARAM_set_time)
 int
 X509_VERIFY_PARAM_add0_policy(X509_VERIFY_PARAM *param, ASN1_OBJECT *policy)
@@ -484,6 +498,7 @@ X509_VERIFY_PARAM_add0_policy(X509_VERIFY_PARAM *param, ASN1_OBJECT *policy)
                return 0;
        return 1;
 }
+LCRYPTO_ALIAS(X509_VERIFY_PARAM_add0_policy)
 int
 X509_VERIFY_PARAM_set1_policies(X509_VERIFY_PARAM *param,
@@ -519,6 +534,7 @@ X509_VERIFY_PARAM_set1_policies(X509_VERIFY_PARAM *param,
        param->flags |= X509_V_FLAG_POLICY_CHECK;
        return 1;
 }
+LCRYPTO_ALIAS(X509_VERIFY_PARAM_set1_policies)
 int
 X509_VERIFY_PARAM_set1_host(X509_VERIFY_PARAM *param,
@@ -529,6 +545,7 @@ X509_VERIFY_PARAM_set1_host(X509_VERIFY_PARAM *param,
        param->id->poisoned = 1;
        return 0;
 }
+LCRYPTO_ALIAS(X509_VERIFY_PARAM_set1_host)
 int
 X509_VERIFY_PARAM_add1_host(X509_VERIFY_PARAM *param,
@@ -539,18 +556,21 @@ X509_VERIFY_PARAM_add1_host(X509_VERIFY_PARAM *param,
        param->id->poisoned = 1;
        return 0;
 }
+LCRYPTO_ALIAS(X509_VERIFY_PARAM_add1_host)
 void
 X509_VERIFY_PARAM_set_hostflags(X509_VERIFY_PARAM *param, unsigned int flags)
 {
        param->id->hostflags = flags;
 }
+LCRYPTO_ALIAS(X509_VERIFY_PARAM_set_hostflags)
 char *
 X509_VERIFY_PARAM_get0_peername(X509_VERIFY_PARAM *param)
 {
        return param->id->peername;
 }
+LCRYPTO_ALIAS(X509_VERIFY_PARAM_get0_peername)
 int
 X509_VERIFY_PARAM_set1_email(X509_VERIFY_PARAM *param,  const char *email,
@@ -562,6 +582,7 @@ X509_VERIFY_PARAM_set1_email(X509_VERIFY_PARAM *param,  const char *email,
        param->id->poisoned = 1;
        return 0;
 }
+LCRYPTO_ALIAS(X509_VERIFY_PARAM_set1_email)
 int
 X509_VERIFY_PARAM_set1_ip(X509_VERIFY_PARAM *param, const unsigned char *ip,
@@ -576,6 +597,7 @@ X509_VERIFY_PARAM_set1_ip(X509_VERIFY_PARAM *param, const unsigned char *ip,
        param->id->poisoned = 1;
        return 0;
 }
+LCRYPTO_ALIAS(X509_VERIFY_PARAM_set1_ip)
 int
 X509_VERIFY_PARAM_set1_ip_asc(X509_VERIFY_PARAM *param, const char *ipasc)
@@ -586,18 +608,21 @@ X509_VERIFY_PARAM_set1_ip_asc(X509_VERIFY_PARAM *param, const char *ipasc)
        iplen = (size_t)a2i_ipadd(ipout, ipasc);
        return X509_VERIFY_PARAM_set1_ip(param, ipout, iplen);
 }
+LCRYPTO_ALIAS(X509_VERIFY_PARAM_set1_ip_asc)
 int
 X509_VERIFY_PARAM_get_depth(const X509_VERIFY_PARAM *param)
 {
        return param->depth;
 }
+LCRYPTO_ALIAS(X509_VERIFY_PARAM_get_depth)
 const char *
 X509_VERIFY_PARAM_get0_name(const X509_VERIFY_PARAM *param)
 {
        return param->name;
 }
+LCRYPTO_ALIAS(X509_VERIFY_PARAM_get0_name)
 static const X509_VERIFY_PARAM_ID _empty_id = { NULL };
@@ -679,6 +704,7 @@ X509_VERIFY_PARAM_add0_table(X509_VERIFY_PARAM *param)
                return 0;
        return 1;
 }
+LCRYPTO_ALIAS(X509_VERIFY_PARAM_add0_table)
 int
 X509_VERIFY_PARAM_get_count(void)
@@ -688,6 +714,7 @@ X509_VERIFY_PARAM_get_count(void)
                num += sk_X509_VERIFY_PARAM_num(param_table);
        return num;
 }
+LCRYPTO_ALIAS(X509_VERIFY_PARAM_get_count)
 const X509_VERIFY_PARAM *
 X509_VERIFY_PARAM_get0(int id)
@@ -697,6 +724,7 @@ X509_VERIFY_PARAM_get0(int id)
                return default_table + id;
        return sk_X509_VERIFY_PARAM_value(param_table, id - num);
 }
+LCRYPTO_ALIAS(X509_VERIFY_PARAM_get0)
 const X509_VERIFY_PARAM *
 X509_VERIFY_PARAM_lookup(const char *name)
@@ -719,6 +747,7 @@ X509_VERIFY_PARAM_lookup(const char *name)
        }
        return NULL;
 }
+LCRYPTO_ALIAS(X509_VERIFY_PARAM_lookup)
 void
 X509_VERIFY_PARAM_table_cleanup(void)
@@ -728,3 +757,4 @@ X509_VERIFY_PARAM_table_cleanup(void)
                    X509_VERIFY_PARAM_free);
        param_table = NULL;
 }
+LCRYPTO_ALIAS(X509_VERIFY_PARAM_table_cleanup)
diff --git a/src/lib/libcrypto/x509/x509cset.c b/src/lib/libcrypto/x509/x509cset.c
index b3af77d90e..7002238394 100644
--- a/src/lib/libcrypto/x509/x509cset.c
+++ b/src/lib/libcrypto/x509/x509cset.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: x509cset.c,v 1.16 2021/11/01 20:53:08 tb Exp $ */
+/* $OpenBSD: x509cset.c,v 1.17 2022/11/14 17:48:50 beck Exp $ */
 /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
 * project 2001.
 */
@@ -71,6 +71,7 @@ X509_CRL_up_ref(X509_CRL *x)
        int refs = CRYPTO_add(&x->references, 1, CRYPTO_LOCK_X509_CRL);
        return (refs > 1) ? 1 : 0;
 }
+LCRYPTO_ALIAS(X509_CRL_up_ref)
 int
 X509_CRL_set_version(X509_CRL *x, long version)
@@ -83,6 +84,7 @@ X509_CRL_set_version(X509_CRL *x, long version)
        }
        return (ASN1_INTEGER_set(x->crl->version, version));
 }
+LCRYPTO_ALIAS(X509_CRL_set_version)
 int
 X509_CRL_set_issuer_name(X509_CRL *x, X509_NAME *name)
@@ -91,6 +93,7 @@ X509_CRL_set_issuer_name(X509_CRL *x, X509_NAME *name)
                return (0);
        return (X509_NAME_set(&x->crl->issuer, name));
 }
+LCRYPTO_ALIAS(X509_CRL_set_issuer_name)
 int
 X509_CRL_set_lastUpdate(X509_CRL *x, const ASN1_TIME *tm)
@@ -109,12 +112,14 @@ X509_CRL_set_lastUpdate(X509_CRL *x, const ASN1_TIME *tm)
        }
        return (in != NULL);
 }
+LCRYPTO_ALIAS(X509_CRL_set_lastUpdate)
 int
 X509_CRL_set1_lastUpdate(X509_CRL *x, const ASN1_TIME *tm)
 {
        return X509_CRL_set_lastUpdate(x, tm);
 }
+LCRYPTO_ALIAS(X509_CRL_set1_lastUpdate)
 int
 X509_CRL_set_nextUpdate(X509_CRL *x, const ASN1_TIME *tm)
@@ -133,12 +138,14 @@ X509_CRL_set_nextUpdate(X509_CRL *x, const ASN1_TIME *tm)
        }
        return (in != NULL);
 }
+LCRYPTO_ALIAS(X509_CRL_set_nextUpdate)
 int
 X509_CRL_set1_nextUpdate(X509_CRL *x, const ASN1_TIME *tm)
 {
        return X509_CRL_set_nextUpdate(x, tm);
 }
+LCRYPTO_ALIAS(X509_CRL_set1_nextUpdate)
 int
 X509_CRL_sort(X509_CRL *c)
@@ -156,24 +163,28 @@ X509_CRL_sort(X509_CRL *c)
        c->crl->enc.modified = 1;
        return 1;
 }
+LCRYPTO_ALIAS(X509_CRL_sort)
 const STACK_OF(X509_EXTENSION) *
 X509_REVOKED_get0_extensions(const X509_REVOKED *x)
 {
        return x->extensions;
 }
+LCRYPTO_ALIAS(X509_REVOKED_get0_extensions)
 const ASN1_TIME *
 X509_REVOKED_get0_revocationDate(const X509_REVOKED *x)
 {
        return x->revocationDate;
 }
+LCRYPTO_ALIAS(X509_REVOKED_get0_revocationDate)
 const ASN1_INTEGER *
 X509_REVOKED_get0_serialNumber(const X509_REVOKED *x)
 {
        return x->serialNumber;
 }
+LCRYPTO_ALIAS(X509_REVOKED_get0_serialNumber)
 int
 X509_REVOKED_set_revocationDate(X509_REVOKED *x, ASN1_TIME *tm)
@@ -192,6 +203,7 @@ X509_REVOKED_set_revocationDate(X509_REVOKED *x, ASN1_TIME *tm)
        }
        return (in != NULL);
 }
+LCRYPTO_ALIAS(X509_REVOKED_set_revocationDate)
 int
 X509_REVOKED_set_serialNumber(X509_REVOKED *x, ASN1_INTEGER *serial)
@@ -210,6 +222,7 @@ X509_REVOKED_set_serialNumber(X509_REVOKED *x, ASN1_INTEGER *serial)
        }
        return (in != NULL);
 }
+LCRYPTO_ALIAS(X509_REVOKED_set_serialNumber)
 int
 i2d_re_X509_CRL_tbs(X509_CRL *crl, unsigned char **pp)
@@ -217,3 +230,4 @@ i2d_re_X509_CRL_tbs(X509_CRL *crl, unsigned char **pp)
        crl->crl->enc.modified = 1;
        return i2d_X509_CRL_INFO(crl->crl, pp);
 }
+LCRYPTO_ALIAS(i2d_re_X509_CRL_tbs)
diff --git a/src/lib/libcrypto/x509/x509name.c b/src/lib/libcrypto/x509/x509name.c
index 878d787846..88f4efa149 100644
--- a/src/lib/libcrypto/x509/x509name.c
+++ b/src/lib/libcrypto/x509/x509name.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: x509name.c,v 1.27 2021/11/01 20:53:08 tb Exp $ */
+/* $OpenBSD: x509name.c,v 1.28 2022/11/14 17:48:50 beck Exp $ */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
 * All rights reserved.
 *
@@ -78,6 +78,7 @@ X509_NAME_get_text_by_NID(X509_NAME *name, int nid, char *buf, int len)
                return (-1);
        return (X509_NAME_get_text_by_OBJ(name, obj, buf, len));
 }
+LCRYPTO_ALIAS(X509_NAME_get_text_by_NID)
 int
 X509_NAME_get_text_by_OBJ(X509_NAME *name, const ASN1_OBJECT *obj, char *buf,
@@ -99,6 +100,7 @@ X509_NAME_get_text_by_OBJ(X509_NAME *name, const ASN1_OBJECT *obj, char *buf,
        }
        return (i);
 }
+LCRYPTO_ALIAS(X509_NAME_get_text_by_OBJ)
 int
 X509_NAME_entry_count(const X509_NAME *name)
@@ -107,6 +109,7 @@ X509_NAME_entry_count(const X509_NAME *name)
                return (0);
        return (sk_X509_NAME_ENTRY_num(name->entries));
 }
+LCRYPTO_ALIAS(X509_NAME_entry_count)
 int
 X509_NAME_get_index_by_NID(const X509_NAME *name, int nid, int lastpos)
@@ -118,6 +121,7 @@ X509_NAME_get_index_by_NID(const X509_NAME *name, int nid, int lastpos)
                return (-2);
        return (X509_NAME_get_index_by_OBJ(name, obj, lastpos));
 }
+LCRYPTO_ALIAS(X509_NAME_get_index_by_NID)
 /* NOTE: you should be passsing -1, not 0 as lastpos */
 int
@@ -141,6 +145,7 @@ X509_NAME_get_index_by_OBJ(const X509_NAME *name, const ASN1_OBJECT *obj,
        }
        return (-1);
 }
+LCRYPTO_ALIAS(X509_NAME_get_index_by_OBJ)
 X509_NAME_ENTRY *
 X509_NAME_get_entry(const X509_NAME *name, int loc)
@@ -151,6 +156,7 @@ X509_NAME_get_entry(const X509_NAME *name, int loc)
        else
                return (sk_X509_NAME_ENTRY_value(name->entries, loc));
 }
+LCRYPTO_ALIAS(X509_NAME_get_entry)
 X509_NAME_ENTRY *
 X509_NAME_delete_entry(X509_NAME *name, int loc)
@@ -189,6 +195,7 @@ X509_NAME_delete_entry(X509_NAME *name, int loc)
                        sk_X509_NAME_ENTRY_value(sk, i)->set--;
        return (ret);
 }
+LCRYPTO_ALIAS(X509_NAME_delete_entry)
 int
 X509_NAME_add_entry_by_OBJ(X509_NAME *name, const ASN1_OBJECT *obj, int type,
@@ -204,6 +211,7 @@ X509_NAME_add_entry_by_OBJ(X509_NAME *name, const ASN1_OBJECT *obj, int type,
        X509_NAME_ENTRY_free(ne);
        return ret;
 }
+LCRYPTO_ALIAS(X509_NAME_add_entry_by_OBJ)
 int
 X509_NAME_add_entry_by_NID(X509_NAME *name, int nid, int type,
@@ -219,6 +227,7 @@ X509_NAME_add_entry_by_NID(X509_NAME *name, int nid, int type,
        X509_NAME_ENTRY_free(ne);
        return ret;
 }
+LCRYPTO_ALIAS(X509_NAME_add_entry_by_NID)
 int
 X509_NAME_add_entry_by_txt(X509_NAME *name, const char *field, int type,
@@ -234,6 +243,7 @@ X509_NAME_add_entry_by_txt(X509_NAME *name, const char *field, int type,
        X509_NAME_ENTRY_free(ne);
        return ret;
 }
+LCRYPTO_ALIAS(X509_NAME_add_entry_by_txt)
 /* if set is -1, append to previous set, 0 'a new one', and 1,
 * prepend to the guy we are about to stomp on. */
@@ -292,6 +302,7 @@ err:
                X509_NAME_ENTRY_free(new_name);
        return (0);
 }
+LCRYPTO_ALIAS(X509_NAME_add_entry)
 X509_NAME_ENTRY *
 X509_NAME_ENTRY_create_by_txt(X509_NAME_ENTRY **ne,
@@ -310,6 +321,7 @@ X509_NAME_ENTRY_create_by_txt(X509_NAME_ENTRY **ne,
        ASN1_OBJECT_free(obj);
        return nentry;
 }
+LCRYPTO_ALIAS(X509_NAME_ENTRY_create_by_txt)
 X509_NAME_ENTRY *
 X509_NAME_ENTRY_create_by_NID(X509_NAME_ENTRY **ne, int nid, int type,
@@ -327,6 +339,7 @@ X509_NAME_ENTRY_create_by_NID(X509_NAME_ENTRY **ne, int nid, int type,
        ASN1_OBJECT_free(obj);
        return nentry;
 }
+LCRYPTO_ALIAS(X509_NAME_ENTRY_create_by_NID)
 X509_NAME_ENTRY *
 X509_NAME_ENTRY_create_by_OBJ(X509_NAME_ENTRY **ne, const ASN1_OBJECT *obj,
@@ -354,6 +367,7 @@ err:
                X509_NAME_ENTRY_free(ret);
        return (NULL);
 }
+LCRYPTO_ALIAS(X509_NAME_ENTRY_create_by_OBJ)
 int
 X509_NAME_ENTRY_set_object(X509_NAME_ENTRY *ne, const ASN1_OBJECT *obj)
@@ -366,6 +380,7 @@ X509_NAME_ENTRY_set_object(X509_NAME_ENTRY *ne, const ASN1_OBJECT *obj)
        ne->object = OBJ_dup(obj);
        return ((ne->object == NULL) ? 0 : 1);
 }
+LCRYPTO_ALIAS(X509_NAME_ENTRY_set_object)
 int
 X509_NAME_ENTRY_set_data(X509_NAME_ENTRY *ne, int type,
@@ -391,6 +406,7 @@ X509_NAME_ENTRY_set_data(X509_NAME_ENTRY *ne, int type,
        }
        return (1);
 }
+LCRYPTO_ALIAS(X509_NAME_ENTRY_set_data)
 ASN1_OBJECT *
 X509_NAME_ENTRY_get_object(const X509_NAME_ENTRY *ne)
@@ -399,6 +415,7 @@ X509_NAME_ENTRY_get_object(const X509_NAME_ENTRY *ne)
                return (NULL);
        return (ne->object);
 }
+LCRYPTO_ALIAS(X509_NAME_ENTRY_get_object)
 ASN1_STRING *
 X509_NAME_ENTRY_get_data(const X509_NAME_ENTRY *ne)
@@ -407,9 +424,11 @@ X509_NAME_ENTRY_get_data(const X509_NAME_ENTRY *ne)
                return (NULL);
        return (ne->value);
 }
+LCRYPTO_ALIAS(X509_NAME_ENTRY_get_data)
 int
 X509_NAME_ENTRY_set(const X509_NAME_ENTRY *ne)
 {
        return (ne->set);
 }
+LCRYPTO_ALIAS(X509_NAME_ENTRY_set)
diff --git a/src/lib/libcrypto/x509/x509rset.c b/src/lib/libcrypto/x509/x509rset.c
index a2dd9e4cd2..6fb622e3cb 100644
--- a/src/lib/libcrypto/x509/x509rset.c
+++ b/src/lib/libcrypto/x509/x509rset.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: x509rset.c,v 1.9 2021/11/01 20:53:08 tb Exp $ */
+/* $OpenBSD: x509rset.c,v 1.10 2022/11/14 17:48:50 beck Exp $ */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
 * All rights reserved.
 *
@@ -73,12 +73,14 @@ X509_REQ_set_version(X509_REQ *x, long version)
        x->req_info->enc.modified = 1;
        return (ASN1_INTEGER_set(x->req_info->version, version));
 }
+LCRYPTO_ALIAS(X509_REQ_set_version)
 long
 X509_REQ_get_version(const X509_REQ *x)
 {
        return ASN1_INTEGER_get(x->req_info->version);
 }
+LCRYPTO_ALIAS(X509_REQ_get_version)
 int
 X509_REQ_set_subject_name(X509_REQ *x, X509_NAME *name)
@@ -88,12 +90,14 @@ X509_REQ_set_subject_name(X509_REQ *x, X509_NAME *name)
        x->req_info->enc.modified = 1;
        return (X509_NAME_set(&x->req_info->subject, name));
 }
+LCRYPTO_ALIAS(X509_REQ_set_subject_name)
 X509_NAME *
 X509_REQ_get_subject_name(const X509_REQ *x)
 {
        return x->req_info->subject;
 }
+LCRYPTO_ALIAS(X509_REQ_get_subject_name)
 int
 X509_REQ_set_pubkey(X509_REQ *x, EVP_PKEY *pkey)
@@ -103,3 +107,4 @@ X509_REQ_set_pubkey(X509_REQ *x, EVP_PKEY *pkey)
        x->req_info->enc.modified = 1;
        return (X509_PUBKEY_set(&x->req_info->pubkey, pkey));
 }
+LCRYPTO_ALIAS(X509_REQ_set_pubkey)
diff --git a/src/lib/libcrypto/x509/x509spki.c b/src/lib/libcrypto/x509/x509spki.c
index 66bbd1e036..2c1b506dcd 100644
--- a/src/lib/libcrypto/x509/x509spki.c
+++ b/src/lib/libcrypto/x509/x509spki.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: x509spki.c,v 1.14 2019/05/23 02:08:34 bcook Exp $ */
+/* $OpenBSD: x509spki.c,v 1.15 2022/11/14 17:48:50 beck Exp $ */
 /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
 * project 1999.
 */
@@ -70,6 +70,7 @@ NETSCAPE_SPKI_set_pubkey(NETSCAPE_SPKI *x, EVP_PKEY *pkey)
                return (0);
        return (X509_PUBKEY_set(&(x->spkac->pubkey), pkey));
 }
+LCRYPTO_ALIAS(NETSCAPE_SPKI_set_pubkey)
 EVP_PKEY *
 NETSCAPE_SPKI_get_pubkey(NETSCAPE_SPKI *x)
@@ -78,6 +79,7 @@ NETSCAPE_SPKI_get_pubkey(NETSCAPE_SPKI *x)
                return (NULL);
        return (X509_PUBKEY_get(x->spkac->pubkey));
 }
+LCRYPTO_ALIAS(NETSCAPE_SPKI_get_pubkey)
 /* Load a Netscape SPKI from a base64 encoded string */
@@ -106,6 +108,7 @@ NETSCAPE_SPKI_b64_decode(const char *str, int len)
        free(spki_der);
        return spki;
 }
+LCRYPTO_ALIAS(NETSCAPE_SPKI_b64_decode)
 /* Generate a base64 encoded string from an SPKI */
@@ -130,3 +133,4 @@ NETSCAPE_SPKI_b64_encode(NETSCAPE_SPKI *spki)
        free(der_spki);
        return b64_str;
 }
+LCRYPTO_ALIAS(NETSCAPE_SPKI_b64_encode)
diff --git a/src/lib/libcrypto/x509/x509type.c b/src/lib/libcrypto/x509/x509type.c
index 7495b9ef04..2d80434d95 100644
--- a/src/lib/libcrypto/x509/x509type.c
+++ b/src/lib/libcrypto/x509/x509type.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: x509type.c,v 1.15 2021/12/12 21:30:14 tb Exp $ */
+/* $OpenBSD: x509type.c,v 1.16 2022/11/14 17:48:50 beck Exp $ */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
 * All rights reserved.
 *
@@ -124,3 +124,4 @@ X509_certificate_type(const X509 *x, const EVP_PKEY *pkey)
                ret |= EVP_PKT_EXP;
        return (ret);
 }
+LCRYPTO_ALIAS(X509_certificate_type)
diff --git a/src/lib/libcrypto/x509/x_all.c b/src/lib/libcrypto/x509/x_all.c
index ec5ed3dc6f..442a27bc7f 100644
--- a/src/lib/libcrypto/x509/x_all.c
+++ b/src/lib/libcrypto/x509/x_all.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: x_all.c,v 1.27 2022/11/12 12:11:14 beck Exp $ */
+/* $OpenBSD: x_all.c,v 1.28 2022/11/14 17:48:50 beck Exp $ */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
 * All rights reserved.
 *
@@ -80,72 +80,84 @@ d2i_X509_bio(BIO *bp, X509 **x509)
 {
        return ASN1_item_d2i_bio(&X509_it, bp, x509);
 }
+LCRYPTO_ALIAS(d2i_X509_bio)
 int
 i2d_X509_bio(BIO *bp, X509 *x509)
 {
        return ASN1_item_i2d_bio(&X509_it, bp, x509);
 }
+LCRYPTO_ALIAS(i2d_X509_bio)
 X509 *
 d2i_X509_fp(FILE *fp, X509 **x509)
 {
        return ASN1_item_d2i_fp(&X509_it, fp, x509);
 }
+LCRYPTO_ALIAS(d2i_X509_fp)
 int
 i2d_X509_fp(FILE *fp, X509 *x509)
 {
        return ASN1_item_i2d_fp(&X509_it, fp, x509);
 }
+LCRYPTO_ALIAS(i2d_X509_fp)
 X509_CRL *
 d2i_X509_CRL_bio(BIO *bp, X509_CRL **crl)
 {
        return ASN1_item_d2i_bio(&X509_CRL_it, bp, crl);
 }
+LCRYPTO_ALIAS(d2i_X509_CRL_bio)
 int
 i2d_X509_CRL_bio(BIO *bp, X509_CRL *crl)
 {
        return ASN1_item_i2d_bio(&X509_CRL_it, bp, crl);
 }
+LCRYPTO_ALIAS(i2d_X509_CRL_bio)
 X509_CRL *
 d2i_X509_CRL_fp(FILE *fp, X509_CRL **crl)
 {
        return ASN1_item_d2i_fp(&X509_CRL_it, fp, crl);
 }
+LCRYPTO_ALIAS(d2i_X509_CRL_fp)
 int
 i2d_X509_CRL_fp(FILE *fp, X509_CRL *crl)
 {
        return ASN1_item_i2d_fp(&X509_CRL_it, fp, crl);
 }
+LCRYPTO_ALIAS(i2d_X509_CRL_fp)
 X509_REQ *
 d2i_X509_REQ_bio(BIO *bp, X509_REQ **req)
 {
        return ASN1_item_d2i_bio(&X509_REQ_it, bp, req);
 }
+LCRYPTO_ALIAS(d2i_X509_REQ_bio)
 int
 i2d_X509_REQ_bio(BIO *bp, X509_REQ *req)
 {
        return ASN1_item_i2d_bio(&X509_REQ_it, bp, req);
 }
+LCRYPTO_ALIAS(i2d_X509_REQ_bio)
 X509_REQ *
 d2i_X509_REQ_fp(FILE *fp, X509_REQ **req)
 {
        return ASN1_item_d2i_fp(&X509_REQ_it, fp, req);
 }
+LCRYPTO_ALIAS(d2i_X509_REQ_fp)
 int
 i2d_X509_REQ_fp(FILE *fp, X509_REQ *req)
 {
        return ASN1_item_i2d_fp(&X509_REQ_it, fp, req);
 }
+LCRYPTO_ALIAS(i2d_X509_REQ_fp)
 #ifndef OPENSSL_NO_RSA
 RSA *
@@ -153,48 +165,56 @@ d2i_RSAPrivateKey_bio(BIO *bp, RSA **rsa)
 {
        return ASN1_item_d2i_bio(&RSAPrivateKey_it, bp, rsa);
 }
+LCRYPTO_ALIAS(d2i_RSAPrivateKey_bio)
 int
 i2d_RSAPrivateKey_bio(BIO *bp, RSA *rsa)
 {
        return ASN1_item_i2d_bio(&RSAPrivateKey_it, bp, rsa);
 }
+LCRYPTO_ALIAS(i2d_RSAPrivateKey_bio)
 RSA *
 d2i_RSAPrivateKey_fp(FILE *fp, RSA **rsa)
 {
        return ASN1_item_d2i_fp(&RSAPrivateKey_it, fp, rsa);
 }
+LCRYPTO_ALIAS(d2i_RSAPrivateKey_fp)
 int
 i2d_RSAPrivateKey_fp(FILE *fp, RSA *rsa)
 {
        return ASN1_item_i2d_fp(&RSAPrivateKey_it, fp, rsa);
 }
+LCRYPTO_ALIAS(i2d_RSAPrivateKey_fp)
 RSA *
 d2i_RSAPublicKey_bio(BIO *bp, RSA **rsa)
 {
        return ASN1_item_d2i_bio(&RSAPublicKey_it, bp, rsa);
 }
+LCRYPTO_ALIAS(d2i_RSAPublicKey_bio)
 int
 i2d_RSAPublicKey_bio(BIO *bp, RSA *rsa)
 {
        return ASN1_item_i2d_bio(&RSAPublicKey_it, bp, rsa);
 }
+LCRYPTO_ALIAS(i2d_RSAPublicKey_bio)
 RSA *
 d2i_RSAPublicKey_fp(FILE *fp, RSA **rsa)
 {
        return ASN1_item_d2i_fp(&RSAPublicKey_it, fp, rsa);
 }
+LCRYPTO_ALIAS(d2i_RSAPublicKey_fp)
 int
 i2d_RSAPublicKey_fp(FILE *fp, RSA *rsa)
 {
        return ASN1_item_i2d_fp(&RSAPublicKey_it, fp, rsa);
 }
+LCRYPTO_ALIAS(i2d_RSAPublicKey_fp)
 #endif
 #ifndef OPENSSL_NO_DSA
@@ -203,24 +223,28 @@ d2i_DSAPrivateKey_bio(BIO *bp, DSA **dsa)
 {
        return ASN1_item_d2i_bio(&DSAPrivateKey_it, bp, dsa);
 }
+LCRYPTO_ALIAS(d2i_DSAPrivateKey_bio)
 int
 i2d_DSAPrivateKey_bio(BIO *bp, DSA *dsa)
 {
        return ASN1_item_i2d_bio(&DSAPrivateKey_it, bp, dsa);
 }
+LCRYPTO_ALIAS(i2d_DSAPrivateKey_bio)
 DSA *
 d2i_DSAPrivateKey_fp(FILE *fp, DSA **dsa)
 {
        return ASN1_item_d2i_fp(&DSAPrivateKey_it, fp, dsa);
 }
+LCRYPTO_ALIAS(d2i_DSAPrivateKey_fp)
 int
 i2d_DSAPrivateKey_fp(FILE *fp, DSA *dsa)
 {
        return ASN1_item_i2d_fp(&DSAPrivateKey_it, fp, dsa);
 }
+LCRYPTO_ALIAS(i2d_DSAPrivateKey_fp)
 #endif
 #ifndef OPENSSL_NO_EC
@@ -229,24 +253,28 @@ d2i_ECPrivateKey_bio(BIO *bp, EC_KEY **eckey)
 {
        return ASN1_d2i_bio_of(EC_KEY, EC_KEY_new, d2i_ECPrivateKey, bp, eckey);
 }
+LCRYPTO_ALIAS(d2i_ECPrivateKey_bio)
 int
 i2d_ECPrivateKey_bio(BIO *bp, EC_KEY *eckey)
 {
        return ASN1_i2d_bio_of(EC_KEY, i2d_ECPrivateKey, bp, eckey);
 }
+LCRYPTO_ALIAS(i2d_ECPrivateKey_bio)
 EC_KEY *
 d2i_ECPrivateKey_fp(FILE *fp, EC_KEY **eckey)
 {
        return ASN1_d2i_fp_of(EC_KEY, EC_KEY_new, d2i_ECPrivateKey, fp, eckey);
 }
+LCRYPTO_ALIAS(d2i_ECPrivateKey_fp)
 int
 i2d_ECPrivateKey_fp(FILE *fp, EC_KEY *eckey)
 {
        return ASN1_i2d_fp_of(EC_KEY, i2d_ECPrivateKey, fp, eckey);
 }
+LCRYPTO_ALIAS(i2d_ECPrivateKey_fp)
 #endif
 X509_SIG *
@@ -254,24 +282,28 @@ d2i_PKCS8_bio(BIO *bp, X509_SIG **p8)
 {
        return ASN1_item_d2i_bio(&X509_SIG_it, bp, p8);
 }
+LCRYPTO_ALIAS(d2i_PKCS8_bio)
 int
 i2d_PKCS8_bio(BIO *bp, X509_SIG *p8)
 {
        return ASN1_item_i2d_bio(&X509_SIG_it, bp, p8);
 }
+LCRYPTO_ALIAS(i2d_PKCS8_bio)
 X509_SIG *
 d2i_PKCS8_fp(FILE *fp, X509_SIG **p8)
 {
        return ASN1_item_d2i_fp(&X509_SIG_it, fp, p8);
 }
+LCRYPTO_ALIAS(d2i_PKCS8_fp)
 int
 i2d_PKCS8_fp(FILE *fp, X509_SIG *p8)
 {
        return ASN1_item_i2d_fp(&X509_SIG_it, fp, p8);
 }
+LCRYPTO_ALIAS(i2d_PKCS8_fp)
 PKCS8_PRIV_KEY_INFO *
 d2i_PKCS8_PRIV_KEY_INFO_bio(BIO *bp, PKCS8_PRIV_KEY_INFO **p8inf)
@@ -279,6 +311,7 @@ d2i_PKCS8_PRIV_KEY_INFO_bio(BIO *bp, PKCS8_PRIV_KEY_INFO **p8inf)
        return ASN1_item_d2i_bio(&PKCS8_PRIV_KEY_INFO_it, bp,
            p8inf);
 }
+LCRYPTO_ALIAS(d2i_PKCS8_PRIV_KEY_INFO_bio)
 int
 i2d_PKCS8_PRIV_KEY_INFO_bio(BIO *bp, PKCS8_PRIV_KEY_INFO *p8inf)
@@ -286,6 +319,7 @@ i2d_PKCS8_PRIV_KEY_INFO_bio(BIO *bp, PKCS8_PRIV_KEY_INFO *p8inf)
        return ASN1_item_i2d_bio(&PKCS8_PRIV_KEY_INFO_it, bp,
            p8inf);
 }
+LCRYPTO_ALIAS(i2d_PKCS8_PRIV_KEY_INFO_bio)
 PKCS8_PRIV_KEY_INFO *
 d2i_PKCS8_PRIV_KEY_INFO_fp(FILE *fp, PKCS8_PRIV_KEY_INFO **p8inf)
@@ -293,6 +327,7 @@ d2i_PKCS8_PRIV_KEY_INFO_fp(FILE *fp, PKCS8_PRIV_KEY_INFO **p8inf)
        return ASN1_item_d2i_fp(&PKCS8_PRIV_KEY_INFO_it, fp,
            p8inf);
 }
+LCRYPTO_ALIAS(d2i_PKCS8_PRIV_KEY_INFO_fp)
 int
 i2d_PKCS8_PRIV_KEY_INFO_fp(FILE *fp, PKCS8_PRIV_KEY_INFO *p8inf)
@@ -300,6 +335,7 @@ i2d_PKCS8_PRIV_KEY_INFO_fp(FILE *fp, PKCS8_PRIV_KEY_INFO *p8inf)
        return ASN1_item_i2d_fp(&PKCS8_PRIV_KEY_INFO_it, fp,
            p8inf);
 }
+LCRYPTO_ALIAS(i2d_PKCS8_PRIV_KEY_INFO_fp)
 EVP_PKEY *
 d2i_PrivateKey_bio(BIO *bp, EVP_PKEY **a)
@@ -307,12 +343,14 @@ d2i_PrivateKey_bio(BIO *bp, EVP_PKEY **a)
        return ASN1_d2i_bio_of(EVP_PKEY, EVP_PKEY_new, d2i_AutoPrivateKey,
            bp, a);
 }
+LCRYPTO_ALIAS(d2i_PrivateKey_bio)
 int
 i2d_PrivateKey_bio(BIO *bp, EVP_PKEY *pkey)
 {
        return ASN1_i2d_bio_of(EVP_PKEY, i2d_PrivateKey, bp, pkey);
 }
+LCRYPTO_ALIAS(i2d_PrivateKey_bio)
 EVP_PKEY *
 d2i_PrivateKey_fp(FILE *fp, EVP_PKEY **a)
@@ -320,12 +358,14 @@ d2i_PrivateKey_fp(FILE *fp, EVP_PKEY **a)
        return ASN1_d2i_fp_of(EVP_PKEY, EVP_PKEY_new, d2i_AutoPrivateKey,
            fp, a);
 }
+LCRYPTO_ALIAS(d2i_PrivateKey_fp)
 int
 i2d_PrivateKey_fp(FILE *fp, EVP_PKEY *pkey)
 {
        return ASN1_i2d_fp_of(EVP_PKEY, i2d_PrivateKey, fp, pkey);
 }
+LCRYPTO_ALIAS(i2d_PrivateKey_fp)
 int
 i2d_PKCS8PrivateKeyInfo_bio(BIO *bp, EVP_PKEY *key)
@@ -340,6 +380,7 @@ i2d_PKCS8PrivateKeyInfo_bio(BIO *bp, EVP_PKEY *key)
        PKCS8_PRIV_KEY_INFO_free(p8inf);
        return ret;
 }
+LCRYPTO_ALIAS(i2d_PKCS8PrivateKeyInfo_bio)
 int
 i2d_PKCS8PrivateKeyInfo_fp(FILE *fp, EVP_PKEY *key)
@@ -353,6 +394,7 @@ i2d_PKCS8PrivateKeyInfo_fp(FILE *fp, EVP_PKEY *key)
        PKCS8_PRIV_KEY_INFO_free(p8inf);
        return ret;
 }
+LCRYPTO_ALIAS(i2d_PKCS8PrivateKeyInfo_fp)
 int
 X509_verify(X509 *a, EVP_PKEY *r)
@@ -362,6 +404,7 @@ X509_verify(X509 *a, EVP_PKEY *r)
        return (ASN1_item_verify(&X509_CINF_it, a->sig_alg,
            a->signature, a->cert_info, r));
 }
+LCRYPTO_ALIAS(X509_verify)
 int
 X509_REQ_verify(X509_REQ *a, EVP_PKEY *r)
@@ -369,6 +412,7 @@ X509_REQ_verify(X509_REQ *a, EVP_PKEY *r)
        return (ASN1_item_verify(&X509_REQ_INFO_it,
            a->sig_alg, a->signature, a->req_info, r));
 }
+LCRYPTO_ALIAS(X509_REQ_verify)
 int
 NETSCAPE_SPKI_verify(NETSCAPE_SPKI *a, EVP_PKEY *r)
@@ -376,6 +420,7 @@ NETSCAPE_SPKI_verify(NETSCAPE_SPKI *a, EVP_PKEY *r)
        return (ASN1_item_verify(&NETSCAPE_SPKAC_it,
            a->sig_algor, a->signature, a->spkac, r));
 }
+LCRYPTO_ALIAS(NETSCAPE_SPKI_verify)
 int
 X509_sign(X509 *x, EVP_PKEY *pkey, const EVP_MD *md)
@@ -385,6 +430,7 @@ X509_sign(X509 *x, EVP_PKEY *pkey, const EVP_MD *md)
            x->cert_info->signature, x->sig_alg, x->signature,
            x->cert_info, pkey, md));
 }
+LCRYPTO_ALIAS(X509_sign)
 int
 X509_sign_ctx(X509 *x, EVP_MD_CTX *ctx)
@@ -394,6 +440,7 @@ X509_sign_ctx(X509 *x, EVP_MD_CTX *ctx)
            x->cert_info->signature, x->sig_alg, x->signature,
            x->cert_info, ctx);
 }
+LCRYPTO_ALIAS(X509_sign_ctx)
 int
 X509_REQ_sign(X509_REQ *x, EVP_PKEY *pkey, const EVP_MD *md)
@@ -401,6 +448,7 @@ X509_REQ_sign(X509_REQ *x, EVP_PKEY *pkey, const EVP_MD *md)
        return (ASN1_item_sign(&X509_REQ_INFO_it,
            x->sig_alg, NULL, x->signature, x->req_info, pkey, md));
 }
+LCRYPTO_ALIAS(X509_REQ_sign)
 int
 X509_REQ_sign_ctx(X509_REQ *x, EVP_MD_CTX *ctx)
@@ -408,6 +456,7 @@ X509_REQ_sign_ctx(X509_REQ *x, EVP_MD_CTX *ctx)
        return ASN1_item_sign_ctx(&X509_REQ_INFO_it,
            x->sig_alg, NULL, x->signature, x->req_info, ctx);
 }
+LCRYPTO_ALIAS(X509_REQ_sign_ctx)
 int
 X509_CRL_sign(X509_CRL *x, EVP_PKEY *pkey, const EVP_MD *md)
@@ -416,6 +465,7 @@ X509_CRL_sign(X509_CRL *x, EVP_PKEY *pkey, const EVP_MD *md)
        return(ASN1_item_sign(&X509_CRL_INFO_it, x->crl->sig_alg,
            x->sig_alg, x->signature, x->crl, pkey, md));
 }
+LCRYPTO_ALIAS(X509_CRL_sign)
 int
 X509_CRL_sign_ctx(X509_CRL *x, EVP_MD_CTX *ctx)
@@ -424,6 +474,7 @@ X509_CRL_sign_ctx(X509_CRL *x, EVP_MD_CTX *ctx)
        return ASN1_item_sign_ctx(&X509_CRL_INFO_it,
            x->crl->sig_alg, x->sig_alg, x->signature, x->crl, ctx);
 }
+LCRYPTO_ALIAS(X509_CRL_sign_ctx)
 int
 NETSCAPE_SPKI_sign(NETSCAPE_SPKI *x, EVP_PKEY *pkey, const EVP_MD *md)
@@ -431,6 +482,7 @@ NETSCAPE_SPKI_sign(NETSCAPE_SPKI *x, EVP_PKEY *pkey, const EVP_MD *md)
        return (ASN1_item_sign(&NETSCAPE_SPKAC_it,
            x->sig_algor, NULL, x->signature, x->spkac, pkey, md));
 }
+LCRYPTO_ALIAS(NETSCAPE_SPKI_sign)
 int
 X509_pubkey_digest(const X509 *data, const EVP_MD *type, unsigned char *md,
@@ -442,6 +494,7 @@ X509_pubkey_digest(const X509 *data, const EVP_MD *type, unsigned char *md,
                return 0;
        return EVP_Digest(key->data, key->length, md, len, type, NULL);
 }
+LCRYPTO_ALIAS(X509_pubkey_digest)
 int
 X509_digest(const X509 *data, const EVP_MD *type, unsigned char *md,
@@ -450,6 +503,7 @@ X509_digest(const X509 *data, const EVP_MD *type, unsigned char *md,
        return (ASN1_item_digest(&X509_it, type, (char *)data,
            md, len));
 }
+LCRYPTO_ALIAS(X509_digest)
 int
 X509_CRL_digest(const X509_CRL *data, const EVP_MD *type, unsigned char *md,
@@ -458,6 +512,7 @@ X509_CRL_digest(const X509_CRL *data, const EVP_MD *type, unsigned char *md,
        return (ASN1_item_digest(&X509_CRL_it, type, (char *)data,
            md, len));
 }
+LCRYPTO_ALIAS(X509_CRL_digest)
 int
 X509_REQ_digest(const X509_REQ *data, const EVP_MD *type, unsigned char *md,
@@ -466,6 +521,7 @@ X509_REQ_digest(const X509_REQ *data, const EVP_MD *type, unsigned char *md,
        return (ASN1_item_digest(&X509_REQ_it, type, (char *)data,
            md, len));
 }
+LCRYPTO_ALIAS(X509_REQ_digest)
 int
 X509_NAME_digest(const X509_NAME *data, const EVP_MD *type, unsigned char *md,
@@ -474,6 +530,7 @@ X509_NAME_digest(const X509_NAME *data, const EVP_MD *type, unsigned char *md,
        return (ASN1_item_digest(&X509_NAME_it, type, (char *)data,
            md, len));
 }
+LCRYPTO_ALIAS(X509_NAME_digest)
 int
 X509_up_ref(X509 *x)
@@ -481,3 +538,4 @@ X509_up_ref(X509 *x)
        int i = CRYPTO_add(&x->references, 1, CRYPTO_LOCK_X509);
        return i > 1 ? 1 : 0;
 }
+LCRYPTO_ALIAS(X509_up_ref)
author	beck <>	2022-11-14 17:48:50 +0000
committer	beck <>	2022-11-14 17:48:50 +0000
commit	109899f1b36632f5f1c469c4f562df69585eb21e (patch)
tree	c42f727f8848b4a56e738422f26e8b44150174e4 /src
parent	fd2db7678bc81cd8abe106c7bd1c724c8b01888d (diff)
download	openbsd-109899f1b36632f5f1c469c4f562df69585eb21e.tar.gz openbsd-109899f1b36632f5f1c469c4f562df69585eb21e.tar.bz2 openbsd-109899f1b36632f5f1c469c4f562df69585eb21e.zip