Hide symbols in hkdf, evp, err, ecdsa, and ec

(part 2 of commit)

ok jsing@

81 files changed, 1345 insertions, 80 deletions

diff --git a/src/lib/libcrypto/Symbols.namespace b/src/lib/libcrypto/Symbols.namespace
index ff5c1f6bd6..c266ee0aab 100644
--- a/src/lib/libcrypto/Symbols.namespace
+++ b/src/lib/libcrypto/Symbols.namespace
@@ -1477,6 +1477,640 @@ _libre_TS_CONF_set_ordering
 _libre_TS_CONF_set_tsa_name
 _libre_TS_CONF_set_ess_cert_id_chain
 _libre_ERR_load_TS_strings
+_libre_HKDF
+_libre_HKDF_extract
+_libre_HKDF_expand
+_libre_EVP_MD_type
+_libre_EVP_MD_pkey_type
+_libre_EVP_MD_size
+_libre_EVP_MD_block_size
+_libre_EVP_MD_flags
+_libre_EVP_MD_meth_new
+_libre_EVP_MD_meth_free
+_libre_EVP_MD_meth_dup
+_libre_EVP_MD_meth_set_input_blocksize
+_libre_EVP_MD_meth_set_result_size
+_libre_EVP_MD_meth_set_app_datasize
+_libre_EVP_MD_meth_set_flags
+_libre_EVP_MD_meth_set_init
+_libre_EVP_MD_meth_set_update
+_libre_EVP_MD_meth_set_final
+_libre_EVP_MD_meth_set_copy
+_libre_EVP_MD_meth_set_cleanup
+_libre_EVP_MD_meth_set_ctrl
+_libre_EVP_MD_CTX_md
+_libre_EVP_MD_CTX_md_data
+_libre_EVP_MD_CTX_pkey_ctx
+_libre_EVP_MD_CTX_set_pkey_ctx
+_libre_EVP_CIPHER_nid
+_libre_EVP_CIPHER_block_size
+_libre_EVP_CIPHER_key_length
+_libre_EVP_CIPHER_iv_length
+_libre_EVP_CIPHER_flags
+_libre_EVP_CIPHER_CTX_cipher
+_libre_EVP_CIPHER_CTX_encrypting
+_libre_EVP_CIPHER_CTX_nid
+_libre_EVP_CIPHER_CTX_block_size
+_libre_EVP_CIPHER_CTX_key_length
+_libre_EVP_CIPHER_CTX_iv_length
+_libre_EVP_CIPHER_CTX_get_iv
+_libre_EVP_CIPHER_CTX_set_iv
+_libre_EVP_CIPHER_CTX_copy
+_libre_EVP_CIPHER_CTX_get_app_data
+_libre_EVP_CIPHER_CTX_set_app_data
+_libre_EVP_CIPHER_CTX_get_cipher_data
+_libre_EVP_CIPHER_CTX_set_cipher_data
+_libre_EVP_CIPHER_CTX_buf_noconst
+_libre_EVP_CIPHER_CTX_flags
+_libre_EVP_CIPHER_meth_new
+_libre_EVP_CIPHER_meth_dup
+_libre_EVP_CIPHER_meth_free
+_libre_EVP_CIPHER_meth_set_iv_length
+_libre_EVP_CIPHER_meth_set_flags
+_libre_EVP_CIPHER_meth_set_impl_ctx_size
+_libre_EVP_CIPHER_meth_set_init
+_libre_EVP_CIPHER_meth_set_do_cipher
+_libre_EVP_CIPHER_meth_set_cleanup
+_libre_EVP_CIPHER_meth_set_set_asn1_params
+_libre_EVP_CIPHER_meth_set_get_asn1_params
+_libre_EVP_CIPHER_meth_set_ctrl
+_libre_EVP_PKEY_new_raw_private_key
+_libre_EVP_PKEY_new_raw_public_key
+_libre_EVP_PKEY_get_raw_private_key
+_libre_EVP_PKEY_get_raw_public_key
+_libre_EVP_Cipher
+_libre_EVP_MD_CTX_new
+_libre_EVP_MD_CTX_free
+_libre_EVP_MD_CTX_init
+_libre_EVP_MD_CTX_reset
+_libre_EVP_MD_CTX_create
+_libre_EVP_MD_CTX_destroy
+_libre_EVP_MD_CTX_cleanup
+_libre_EVP_MD_CTX_copy_ex
+_libre_EVP_MD_CTX_set_flags
+_libre_EVP_MD_CTX_clear_flags
+_libre_EVP_MD_CTX_ctrl
+_libre_EVP_MD_CTX_test_flags
+_libre_EVP_DigestInit_ex
+_libre_EVP_DigestUpdate
+_libre_EVP_DigestFinal_ex
+_libre_EVP_Digest
+_libre_EVP_MD_CTX_copy
+_libre_EVP_DigestInit
+_libre_EVP_DigestFinal
+_libre_EVP_read_pw_string
+_libre_EVP_read_pw_string_min
+_libre_EVP_set_pw_prompt
+_libre_EVP_get_pw_prompt
+_libre_EVP_BytesToKey
+_libre_EVP_CIPHER_CTX_set_flags
+_libre_EVP_CIPHER_CTX_clear_flags
+_libre_EVP_CIPHER_CTX_test_flags
+_libre_EVP_EncryptInit
+_libre_EVP_EncryptInit_ex
+_libre_EVP_EncryptUpdate
+_libre_EVP_EncryptFinal_ex
+_libre_EVP_EncryptFinal
+_libre_EVP_DecryptInit
+_libre_EVP_DecryptInit_ex
+_libre_EVP_DecryptUpdate
+_libre_EVP_DecryptFinal_ex
+_libre_EVP_DecryptFinal
+_libre_EVP_CipherInit
+_libre_EVP_CipherInit_ex
+_libre_EVP_CipherUpdate
+_libre_EVP_CipherFinal_ex
+_libre_EVP_CipherFinal
+_libre_EVP_SignFinal
+_libre_EVP_VerifyFinal
+_libre_EVP_DigestSignInit
+_libre_EVP_DigestSignFinal
+_libre_EVP_DigestSign
+_libre_EVP_DigestVerifyInit
+_libre_EVP_DigestVerifyFinal
+_libre_EVP_DigestVerify
+_libre_EVP_OpenInit
+_libre_EVP_OpenFinal
+_libre_EVP_SealInit
+_libre_EVP_SealFinal
+_libre_EVP_ENCODE_CTX_new
+_libre_EVP_ENCODE_CTX_free
+_libre_EVP_EncodeInit
+_libre_EVP_EncodeUpdate
+_libre_EVP_EncodeFinal
+_libre_EVP_EncodeBlock
+_libre_EVP_DecodeInit
+_libre_EVP_DecodeUpdate
+_libre_EVP_DecodeFinal
+_libre_EVP_DecodeBlock
+_libre_EVP_CIPHER_CTX_init
+_libre_EVP_CIPHER_CTX_cleanup
+_libre_EVP_CIPHER_CTX_new
+_libre_EVP_CIPHER_CTX_free
+_libre_EVP_CIPHER_CTX_reset
+_libre_EVP_CIPHER_CTX_set_key_length
+_libre_EVP_CIPHER_CTX_set_padding
+_libre_EVP_CIPHER_CTX_ctrl
+_libre_EVP_CIPHER_CTX_rand_key
+_libre_BIO_f_md
+_libre_BIO_f_base64
+_libre_BIO_f_cipher
+_libre_BIO_set_cipher
+_libre_EVP_md_null
+_libre_EVP_md4
+_libre_EVP_md5
+_libre_EVP_md5_sha1
+_libre_EVP_sha1
+_libre_EVP_sha224
+_libre_EVP_sha256
+_libre_EVP_sha384
+_libre_EVP_sha512
+_libre_EVP_sha512_224
+_libre_EVP_sha512_256
+_libre_EVP_sha3_224
+_libre_EVP_sha3_256
+_libre_EVP_sha3_384
+_libre_EVP_sha3_512
+_libre_EVP_sm3
+_libre_EVP_ripemd160
+_libre_EVP_whirlpool
+_libre_EVP_gostr341194
+_libre_EVP_gost2814789imit
+_libre_EVP_streebog256
+_libre_EVP_streebog512
+_libre_EVP_enc_null
+_libre_EVP_des_ecb
+_libre_EVP_des_ede
+_libre_EVP_des_ede3
+_libre_EVP_des_ede_ecb
+_libre_EVP_des_ede3_ecb
+_libre_EVP_des_cfb64
+_libre_EVP_des_cfb1
+_libre_EVP_des_cfb8
+_libre_EVP_des_ede_cfb64
+_libre_EVP_des_ede3_cfb64
+_libre_EVP_des_ede3_cfb1
+_libre_EVP_des_ede3_cfb8
+_libre_EVP_des_ofb
+_libre_EVP_des_ede_ofb
+_libre_EVP_des_ede3_ofb
+_libre_EVP_des_cbc
+_libre_EVP_des_ede_cbc
+_libre_EVP_des_ede3_cbc
+_libre_EVP_desx_cbc
+_libre_EVP_rc4
+_libre_EVP_rc4_40
+_libre_EVP_rc4_hmac_md5
+_libre_EVP_idea_ecb
+_libre_EVP_idea_cfb64
+_libre_EVP_idea_ofb
+_libre_EVP_idea_cbc
+_libre_EVP_rc2_ecb
+_libre_EVP_rc2_cbc
+_libre_EVP_rc2_40_cbc
+_libre_EVP_rc2_64_cbc
+_libre_EVP_rc2_cfb64
+_libre_EVP_rc2_ofb
+_libre_EVP_bf_ecb
+_libre_EVP_bf_cbc
+_libre_EVP_bf_cfb64
+_libre_EVP_bf_ofb
+_libre_EVP_cast5_ecb
+_libre_EVP_cast5_cbc
+_libre_EVP_cast5_cfb64
+_libre_EVP_cast5_ofb
+_libre_EVP_aes_128_ecb
+_libre_EVP_aes_128_cbc
+_libre_EVP_aes_128_cfb1
+_libre_EVP_aes_128_cfb8
+_libre_EVP_aes_128_cfb128
+_libre_EVP_aes_128_ofb
+_libre_EVP_aes_128_ctr
+_libre_EVP_aes_128_ccm
+_libre_EVP_aes_128_gcm
+_libre_EVP_aes_128_wrap
+_libre_EVP_aes_128_xts
+_libre_EVP_aes_192_ecb
+_libre_EVP_aes_192_cbc
+_libre_EVP_aes_192_cfb1
+_libre_EVP_aes_192_cfb8
+_libre_EVP_aes_192_cfb128
+_libre_EVP_aes_192_ofb
+_libre_EVP_aes_192_ctr
+_libre_EVP_aes_192_ccm
+_libre_EVP_aes_192_gcm
+_libre_EVP_aes_192_wrap
+_libre_EVP_aes_256_ecb
+_libre_EVP_aes_256_cbc
+_libre_EVP_aes_256_cfb1
+_libre_EVP_aes_256_cfb8
+_libre_EVP_aes_256_cfb128
+_libre_EVP_aes_256_ofb
+_libre_EVP_aes_256_ctr
+_libre_EVP_aes_256_ccm
+_libre_EVP_aes_256_gcm
+_libre_EVP_aes_256_wrap
+_libre_EVP_aes_256_xts
+_libre_EVP_chacha20_poly1305
+_libre_EVP_aes_128_cbc_hmac_sha1
+_libre_EVP_aes_256_cbc_hmac_sha1
+_libre_EVP_camellia_128_ecb
+_libre_EVP_camellia_128_cbc
+_libre_EVP_camellia_128_cfb1
+_libre_EVP_camellia_128_cfb8
+_libre_EVP_camellia_128_cfb128
+_libre_EVP_camellia_128_ofb
+_libre_EVP_camellia_192_ecb
+_libre_EVP_camellia_192_cbc
+_libre_EVP_camellia_192_cfb1
+_libre_EVP_camellia_192_cfb8
+_libre_EVP_camellia_192_cfb128
+_libre_EVP_camellia_192_ofb
+_libre_EVP_camellia_256_ecb
+_libre_EVP_camellia_256_cbc
+_libre_EVP_camellia_256_cfb1
+_libre_EVP_camellia_256_cfb8
+_libre_EVP_camellia_256_cfb128
+_libre_EVP_camellia_256_ofb
+_libre_EVP_chacha20
+_libre_EVP_gost2814789_ecb
+_libre_EVP_gost2814789_cfb64
+_libre_EVP_gost2814789_cnt
+_libre_EVP_sm4_ecb
+_libre_EVP_sm4_cbc
+_libre_EVP_sm4_cfb128
+_libre_EVP_sm4_ofb
+_libre_EVP_sm4_ctr
+_libre_OPENSSL_add_all_algorithms_noconf
+_libre_OPENSSL_add_all_algorithms_conf
+_libre_OpenSSL_add_all_ciphers
+_libre_OpenSSL_add_all_digests
+_libre_EVP_add_cipher
+_libre_EVP_add_digest
+_libre_EVP_get_cipherbyname
+_libre_EVP_get_digestbyname
+_libre_EVP_cleanup
+_libre_EVP_CIPHER_do_all
+_libre_EVP_CIPHER_do_all_sorted
+_libre_EVP_MD_do_all
+_libre_EVP_MD_do_all_sorted
+_libre_EVP_PKEY_decrypt_old
+_libre_EVP_PKEY_encrypt_old
+_libre_EVP_PKEY_type
+_libre_EVP_PKEY_id
+_libre_EVP_PKEY_base_id
+_libre_EVP_PKEY_bits
+_libre_EVP_PKEY_security_bits
+_libre_EVP_PKEY_size
+_libre_EVP_PKEY_set_type
+_libre_EVP_PKEY_set_type_str
+_libre_EVP_PKEY_assign
+_libre_EVP_PKEY_get0
+_libre_EVP_PKEY_get0_hmac
+_libre_EVP_PKEY_get0_RSA
+_libre_EVP_PKEY_get1_RSA
+_libre_EVP_PKEY_set1_RSA
+_libre_EVP_PKEY_get0_DSA
+_libre_EVP_PKEY_get1_DSA
+_libre_EVP_PKEY_set1_DSA
+_libre_EVP_PKEY_get0_DH
+_libre_EVP_PKEY_get1_DH
+_libre_EVP_PKEY_set1_DH
+_libre_EVP_PKEY_get0_EC_KEY
+_libre_EVP_PKEY_get1_EC_KEY
+_libre_EVP_PKEY_set1_EC_KEY
+_libre_EVP_PKEY_new
+_libre_EVP_PKEY_free
+_libre_EVP_PKEY_up_ref
+_libre_d2i_PublicKey
+_libre_i2d_PublicKey
+_libre_d2i_PrivateKey
+_libre_d2i_AutoPrivateKey
+_libre_i2d_PrivateKey
+_libre_EVP_PKEY_copy_parameters
+_libre_EVP_PKEY_missing_parameters
+_libre_EVP_PKEY_save_parameters
+_libre_EVP_PKEY_cmp_parameters
+_libre_EVP_PKEY_cmp
+_libre_EVP_PKEY_print_public
+_libre_EVP_PKEY_print_private
+_libre_EVP_PKEY_print_params
+_libre_EVP_PKEY_get_default_digest_nid
+_libre_EVP_CIPHER_type
+_libre_EVP_CIPHER_param_to_asn1
+_libre_EVP_CIPHER_asn1_to_param
+_libre_EVP_CIPHER_set_asn1_iv
+_libre_EVP_CIPHER_get_asn1_iv
+_libre_PKCS5_PBE_keyivgen
+_libre_PKCS5_PBKDF2_HMAC_SHA1
+_libre_PKCS5_PBKDF2_HMAC
+_libre_PKCS5_v2_PBE_keyivgen
+_libre_PKCS5_PBE_add
+_libre_EVP_PBE_CipherInit
+_libre_EVP_PBE_alg_add_type
+_libre_EVP_PBE_alg_add
+_libre_EVP_PBE_find
+_libre_EVP_PBE_cleanup
+_libre_EVP_PKEY_asn1_get_count
+_libre_EVP_PKEY_asn1_get0
+_libre_EVP_PKEY_asn1_find
+_libre_EVP_PKEY_asn1_find_str
+_libre_EVP_PKEY_asn1_add0
+_libre_EVP_PKEY_asn1_add_alias
+_libre_EVP_PKEY_asn1_get0_info
+_libre_EVP_PKEY_get0_asn1
+_libre_EVP_PKEY_asn1_new
+_libre_EVP_PKEY_asn1_copy
+_libre_EVP_PKEY_asn1_free
+_libre_EVP_PKEY_asn1_set_public
+_libre_EVP_PKEY_asn1_set_private
+_libre_EVP_PKEY_asn1_set_param
+_libre_EVP_PKEY_asn1_set_free
+_libre_EVP_PKEY_asn1_set_ctrl
+_libre_EVP_PKEY_asn1_set_security_bits
+_libre_EVP_PKEY_asn1_set_check
+_libre_EVP_PKEY_asn1_set_public_check
+_libre_EVP_PKEY_asn1_set_param_check
+_libre_EVP_PKEY_meth_find
+_libre_EVP_PKEY_meth_new
+_libre_EVP_PKEY_meth_get0_info
+_libre_EVP_PKEY_meth_copy
+_libre_EVP_PKEY_meth_free
+_libre_EVP_PKEY_meth_add0
+_libre_EVP_PKEY_CTX_new
+_libre_EVP_PKEY_CTX_new_id
+_libre_EVP_PKEY_CTX_dup
+_libre_EVP_PKEY_CTX_free
+_libre_EVP_PKEY_CTX_ctrl
+_libre_EVP_PKEY_CTX_ctrl_str
+_libre_EVP_PKEY_CTX_get_operation
+_libre_EVP_PKEY_CTX_set0_keygen_info
+_libre_EVP_PKEY_new_mac_key
+_libre_EVP_PKEY_new_CMAC_key
+_libre_EVP_PKEY_CTX_set_data
+_libre_EVP_PKEY_CTX_get_data
+_libre_EVP_PKEY_CTX_get0_pkey
+_libre_EVP_PKEY_CTX_get0_peerkey
+_libre_EVP_PKEY_CTX_set_app_data
+_libre_EVP_PKEY_CTX_get_app_data
+_libre_EVP_PKEY_sign_init
+_libre_EVP_PKEY_sign
+_libre_EVP_PKEY_verify_init
+_libre_EVP_PKEY_verify
+_libre_EVP_PKEY_verify_recover_init
+_libre_EVP_PKEY_verify_recover
+_libre_EVP_PKEY_encrypt_init
+_libre_EVP_PKEY_encrypt
+_libre_EVP_PKEY_decrypt_init
+_libre_EVP_PKEY_decrypt
+_libre_EVP_PKEY_derive_init
+_libre_EVP_PKEY_derive_set_peer
+_libre_EVP_PKEY_derive
+_libre_EVP_PKEY_paramgen_init
+_libre_EVP_PKEY_paramgen
+_libre_EVP_PKEY_keygen_init
+_libre_EVP_PKEY_keygen
+_libre_EVP_PKEY_check
+_libre_EVP_PKEY_public_check
+_libre_EVP_PKEY_param_check
+_libre_EVP_PKEY_CTX_set_cb
+_libre_EVP_PKEY_CTX_get_cb
+_libre_EVP_PKEY_CTX_get_keygen_info
+_libre_EVP_PKEY_meth_set_init
+_libre_EVP_PKEY_meth_set_copy
+_libre_EVP_PKEY_meth_set_cleanup
+_libre_EVP_PKEY_meth_set_paramgen
+_libre_EVP_PKEY_meth_set_keygen
+_libre_EVP_PKEY_meth_set_sign
+_libre_EVP_PKEY_meth_set_verify
+_libre_EVP_PKEY_meth_set_verify_recover
+_libre_EVP_PKEY_meth_set_signctx
+_libre_EVP_PKEY_meth_set_verifyctx
+_libre_EVP_PKEY_meth_set_encrypt
+_libre_EVP_PKEY_meth_set_decrypt
+_libre_EVP_PKEY_meth_set_derive
+_libre_EVP_PKEY_meth_set_ctrl
+_libre_EVP_PKEY_meth_set_check
+_libre_EVP_PKEY_meth_set_public_check
+_libre_EVP_PKEY_meth_set_param_check
+_libre_EVP_aead_aes_128_gcm
+_libre_EVP_aead_aes_256_gcm
+_libre_EVP_aead_chacha20_poly1305
+_libre_EVP_aead_xchacha20_poly1305
+_libre_EVP_AEAD_key_length
+_libre_EVP_AEAD_nonce_length
+_libre_EVP_AEAD_max_overhead
+_libre_EVP_AEAD_max_tag_len
+_libre_EVP_AEAD_CTX_new
+_libre_EVP_AEAD_CTX_free
+_libre_EVP_AEAD_CTX_init
+_libre_EVP_AEAD_CTX_cleanup
+_libre_EVP_AEAD_CTX_seal
+_libre_EVP_AEAD_CTX_open
+_libre_ERR_load_EVP_strings
+_libre_ERR_put_error
+_libre_ERR_set_error_data
+_libre_ERR_get_error
+_libre_ERR_get_error_line
+_libre_ERR_get_error_line_data
+_libre_ERR_peek_error
+_libre_ERR_peek_error_line
+_libre_ERR_peek_error_line_data
+_libre_ERR_peek_last_error
+_libre_ERR_peek_last_error_line
+_libre_ERR_peek_last_error_line_data
+_libre_ERR_clear_error
+_libre_ERR_error_string
+_libre_ERR_error_string_n
+_libre_ERR_lib_error_string
+_libre_ERR_func_error_string
+_libre_ERR_reason_error_string
+_libre_ERR_print_errors_cb
+_libre_ERR_print_errors_fp
+_libre_ERR_print_errors
+_libre_ERR_asprintf_error_data
+_libre_ERR_add_error_data
+_libre_ERR_add_error_vdata
+_libre_ERR_load_strings
+_libre_ERR_unload_strings
+_libre_ERR_load_ERR_strings
+_libre_ERR_load_crypto_strings
+_libre_ERR_free_strings
+_libre_ERR_remove_thread_state
+_libre_ERR_remove_state
+_libre_ERR_get_state
+_libre_ERR_get_string_table
+_libre_ERR_get_err_state_table
+_libre_ERR_release_err_state_table
+_libre_ERR_get_next_error_library
+_libre_ERR_set_mark
+_libre_ERR_pop_to_mark
+_libre_ERR_get_implementation
+_libre_ERR_set_implementation
+_libre_ECDSA_SIG_new
+_libre_ECDSA_SIG_free
+_libre_i2d_ECDSA_SIG
+_libre_d2i_ECDSA_SIG
+_libre_ECDSA_SIG_get0
+_libre_ECDSA_SIG_get0_r
+_libre_ECDSA_SIG_get0_s
+_libre_ECDSA_SIG_set0
+_libre_ECDSA_do_sign
+_libre_ECDSA_do_sign_ex
+_libre_ECDSA_do_verify
+_libre_ECDSA_OpenSSL
+_libre_ECDSA_set_default_method
+_libre_ECDSA_get_default_method
+_libre_ECDSA_set_method
+_libre_ECDSA_size
+_libre_ECDSA_sign_setup
+_libre_ECDSA_sign
+_libre_ECDSA_sign_ex
+_libre_ECDSA_verify
+_libre_ECDSA_get_ex_new_index
+_libre_ECDSA_set_ex_data
+_libre_ECDSA_get_ex_data
+_libre_EC_KEY_METHOD_set_sign
+_libre_EC_KEY_METHOD_set_verify
+_libre_EC_KEY_METHOD_get_sign
+_libre_EC_KEY_METHOD_get_verify
+_libre_ERR_load_ECDSA_strings
+_libre_ECDH_OpenSSL
+_libre_ECDH_set_default_method
+_libre_ECDH_get_default_method
+_libre_ECDH_set_method
+_libre_ECDH_size
+_libre_ECDH_compute_key
+_libre_ECDH_get_ex_new_index
+_libre_ECDH_set_ex_data
+_libre_ECDH_get_ex_data
+_libre_ERR_load_ECDH_strings
+_libre_EC_GFp_simple_method
+_libre_EC_GFp_mont_method
+_libre_EC_GROUP_new
+_libre_EC_GROUP_free
+_libre_EC_GROUP_clear_free
+_libre_EC_GROUP_copy
+_libre_EC_GROUP_dup
+_libre_EC_GROUP_method_of
+_libre_EC_METHOD_get_field_type
+_libre_EC_GROUP_set_generator
+_libre_EC_GROUP_get0_generator
+_libre_EC_GROUP_get_order
+_libre_EC_GROUP_order_bits
+_libre_EC_GROUP_get_cofactor
+_libre_EC_GROUP_set_curve_name
+_libre_EC_GROUP_get_curve_name
+_libre_EC_GROUP_set_asn1_flag
+_libre_EC_GROUP_get_asn1_flag
+_libre_EC_GROUP_set_point_conversion_form
+_libre_EC_GROUP_get_point_conversion_form
+_libre_EC_GROUP_get0_seed
+_libre_EC_GROUP_get_seed_len
+_libre_EC_GROUP_set_seed
+_libre_EC_GROUP_set_curve
+_libre_EC_GROUP_get_curve
+_libre_EC_GROUP_set_curve_GFp
+_libre_EC_GROUP_get_curve_GFp
+_libre_EC_GROUP_get_degree
+_libre_EC_GROUP_check
+_libre_EC_GROUP_check_discriminant
+_libre_EC_GROUP_cmp
+_libre_EC_GROUP_new_curve_GFp
+_libre_EC_GROUP_new_by_curve_name
+_libre_EC_get_builtin_curves
+_libre_EC_curve_nid2nist
+_libre_EC_curve_nist2nid
+_libre_EC_POINT_new
+_libre_EC_POINT_free
+_libre_EC_POINT_clear_free
+_libre_EC_POINT_copy
+_libre_EC_POINT_dup
+_libre_EC_POINT_method_of
+_libre_EC_POINT_set_to_infinity
+_libre_EC_POINT_set_affine_coordinates
+_libre_EC_POINT_get_affine_coordinates
+_libre_EC_POINT_set_compressed_coordinates
+_libre_EC_POINT_set_Jprojective_coordinates_GFp
+_libre_EC_POINT_get_Jprojective_coordinates_GFp
+_libre_EC_POINT_set_affine_coordinates_GFp
+_libre_EC_POINT_get_affine_coordinates_GFp
+_libre_EC_POINT_set_compressed_coordinates_GFp
+_libre_EC_POINT_point2oct
+_libre_EC_POINT_oct2point
+_libre_EC_POINT_point2bn
+_libre_EC_POINT_bn2point
+_libre_EC_POINT_point2hex
+_libre_EC_POINT_hex2point
+_libre_EC_POINT_add
+_libre_EC_POINT_dbl
+_libre_EC_POINT_invert
+_libre_EC_POINT_is_at_infinity
+_libre_EC_POINT_is_on_curve
+_libre_EC_POINT_cmp
+_libre_EC_POINT_make_affine
+_libre_EC_POINTs_make_affine
+_libre_EC_POINTs_mul
+_libre_EC_POINT_mul
+_libre_EC_GROUP_precompute_mult
+_libre_EC_GROUP_have_precompute_mult
+_libre_EC_GROUP_get_basis_type
+_libre_d2i_ECPKParameters
+_libre_i2d_ECPKParameters
+_libre_ECPKParameters_print
+_libre_ECPKParameters_print_fp
+_libre_EC_KEY_new
+_libre_EC_KEY_get_flags
+_libre_EC_KEY_set_flags
+_libre_EC_KEY_clear_flags
+_libre_EC_KEY_new_by_curve_name
+_libre_EC_KEY_free
+_libre_EC_KEY_copy
+_libre_EC_KEY_dup
+_libre_EC_KEY_up_ref
+_libre_EC_KEY_get0_group
+_libre_EC_KEY_set_group
+_libre_EC_KEY_get0_private_key
+_libre_EC_KEY_set_private_key
+_libre_EC_KEY_get0_public_key
+_libre_EC_KEY_set_public_key
+_libre_EC_KEY_get_enc_flags
+_libre_EC_KEY_set_enc_flags
+_libre_EC_KEY_get_conv_form
+_libre_EC_KEY_set_conv_form
+_libre_EC_KEY_set_asn1_flag
+_libre_EC_KEY_precompute_mult
+_libre_EC_KEY_generate_key
+_libre_EC_KEY_check_key
+_libre_EC_KEY_set_public_key_affine_coordinates
+_libre_d2i_ECPrivateKey
+_libre_i2d_ECPrivateKey
+_libre_d2i_ECParameters
+_libre_i2d_ECParameters
+_libre_o2i_ECPublicKey
+_libre_i2o_ECPublicKey
+_libre_ECParameters_print
+_libre_EC_KEY_print
+_libre_ECParameters_print_fp
+_libre_EC_KEY_print_fp
+_libre_EC_KEY_set_ex_data
+_libre_EC_KEY_get_ex_data
+_libre_EC_KEY_OpenSSL
+_libre_EC_KEY_get_default_method
+_libre_EC_KEY_set_default_method
+_libre_EC_KEY_get_method
+_libre_EC_KEY_set_method
+_libre_EC_KEY_new_method
+_libre_EC_KEY_METHOD_new
+_libre_EC_KEY_METHOD_free
+_libre_EC_KEY_METHOD_set_init
+_libre_EC_KEY_METHOD_set_keygen
+_libre_EC_KEY_METHOD_set_compute_key
+_libre_EC_KEY_METHOD_get_init
+_libre_EC_KEY_METHOD_get_keygen
+_libre_EC_KEY_METHOD_get_compute_key
+_libre_ECParameters_dup
+_libre_ERR_load_EC_strings
 _libre_RC2_set_key
 _libre_RC2_ecb_encrypt
 _libre_RC2_encrypt
diff --git a/src/lib/libcrypto/ec/ec_asn1.c b/src/lib/libcrypto/ec/ec_asn1.c
index 6aedab9774..0435f0a75f 100644
--- a/src/lib/libcrypto/ec/ec_asn1.c
+++ b/src/lib/libcrypto/ec/ec_asn1.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: ec_asn1.c,v 1.46 2023/06/27 07:28:57 tb Exp $ */
+/* $OpenBSD: ec_asn1.c,v 1.47 2023/07/07 13:54:45 beck Exp $ */
 /*
  * Written by Nils Larsch for the OpenSSL project.
  */
@@ -72,6 +72,7 @@ EC_GROUP_get_basis_type(const EC_GROUP *group)
 {
         return 0;
 }
+LCRYPTO_ALIAS(EC_GROUP_get_basis_type);
 
 /* some structures needed for the asn1 encoding */
 typedef struct x9_62_pentanomial_st {
@@ -184,12 +185,14 @@ X9_62_PENTANOMIAL_new(void)
 {
         return (X9_62_PENTANOMIAL*)ASN1_item_new(&X9_62_PENTANOMIAL_it);
 }
+LCRYPTO_ALIAS(X9_62_PENTANOMIAL_new);
 
 void
 X9_62_PENTANOMIAL_free(X9_62_PENTANOMIAL *a)
 {
         ASN1_item_free((ASN1_VALUE *)a, &X9_62_PENTANOMIAL_it);
 }
+LCRYPTO_ALIAS(X9_62_PENTANOMIAL_free);
 
 static const ASN1_TEMPLATE char_two_def_tt = {
         .flags = 0,
@@ -284,12 +287,14 @@ X9_62_CHARACTERISTIC_TWO_new(void)
 {
         return (X9_62_CHARACTERISTIC_TWO*)ASN1_item_new(&X9_62_CHARACTERISTIC_TWO_it);
 }
+LCRYPTO_ALIAS(X9_62_CHARACTERISTIC_TWO_new);
 
 void
 X9_62_CHARACTERISTIC_TWO_free(X9_62_CHARACTERISTIC_TWO *a)
 {
         ASN1_item_free((ASN1_VALUE *)a, &X9_62_CHARACTERISTIC_TWO_it);
 }
+LCRYPTO_ALIAS(X9_62_CHARACTERISTIC_TWO_free);
 
 static const ASN1_TEMPLATE fieldID_def_tt = {
         .flags = 0,
@@ -455,12 +460,14 @@ ECPARAMETERS_new(void)
 {
         return (ECPARAMETERS*)ASN1_item_new(&ECPARAMETERS_it);
 }
+LCRYPTO_ALIAS(ECPARAMETERS_new);
 
 void
 ECPARAMETERS_free(ECPARAMETERS *a)
 {
         ASN1_item_free((ASN1_VALUE *)a, &ECPARAMETERS_it);
 }
+LCRYPTO_ALIAS(ECPARAMETERS_free);
 
 static const ASN1_TEMPLATE ECPKPARAMETERS_ch_tt[] = {
         {
@@ -507,24 +514,28 @@ d2i_ECPKPARAMETERS(ECPKPARAMETERS **a, const unsigned char **in, long len)
         return (ECPKPARAMETERS *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
             &ECPKPARAMETERS_it);
 }
+LCRYPTO_ALIAS(d2i_ECPKPARAMETERS);
 
 int
 i2d_ECPKPARAMETERS(const ECPKPARAMETERS *a, unsigned char **out)
 {
         return ASN1_item_i2d((ASN1_VALUE *)a, out, &ECPKPARAMETERS_it);
 }
+LCRYPTO_ALIAS(i2d_ECPKPARAMETERS);
 
 ECPKPARAMETERS *
 ECPKPARAMETERS_new(void)
 {
         return (ECPKPARAMETERS *)ASN1_item_new(&ECPKPARAMETERS_it);
 }
+LCRYPTO_ALIAS(ECPKPARAMETERS_new);
 
 void
 ECPKPARAMETERS_free(ECPKPARAMETERS *a)
 {
         ASN1_item_free((ASN1_VALUE *)a, &ECPKPARAMETERS_it);
 }
+LCRYPTO_ALIAS(ECPKPARAMETERS_free);
 
 static const ASN1_TEMPLATE EC_PRIVATEKEY_seq_tt[] = {
         {
@@ -578,24 +589,28 @@ d2i_EC_PRIVATEKEY(EC_PRIVATEKEY **a, const unsigned char **in, long len)
         return (EC_PRIVATEKEY *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
             &EC_PRIVATEKEY_it);
 }
+LCRYPTO_ALIAS(d2i_EC_PRIVATEKEY);
 
 int
 i2d_EC_PRIVATEKEY(const EC_PRIVATEKEY *a, unsigned char **out)
 {
         return ASN1_item_i2d((ASN1_VALUE *)a, out, &EC_PRIVATEKEY_it);
 }
+LCRYPTO_ALIAS(i2d_EC_PRIVATEKEY);
 
 EC_PRIVATEKEY *
 EC_PRIVATEKEY_new(void)
 {
         return (EC_PRIVATEKEY *)ASN1_item_new(&EC_PRIVATEKEY_it);
 }
+LCRYPTO_ALIAS(EC_PRIVATEKEY_new);
 
 void
 EC_PRIVATEKEY_free(EC_PRIVATEKEY *a)
 {
         ASN1_item_free((ASN1_VALUE *)a, &EC_PRIVATEKEY_it);
 }
+LCRYPTO_ALIAS(EC_PRIVATEKEY_free);
 
 /* some declarations of internal function */
 
@@ -1101,6 +1116,7 @@ d2i_ECPKParameters(EC_GROUP **a, const unsigned char **in, long len)
         ECPKPARAMETERS_free(params);
         return (group);
 }
+LCRYPTO_ALIAS(d2i_ECPKParameters);
 
 int
 i2d_ECPKParameters(const EC_GROUP *a, unsigned char **out)
@@ -1119,6 +1135,7 @@ i2d_ECPKParameters(const EC_GROUP *a, unsigned char **out)
         ECPKPARAMETERS_free(tmp);
         return (ret);
 }
+LCRYPTO_ALIAS(i2d_ECPKParameters);
 
 /* some EC_KEY functions */
 
@@ -1213,6 +1230,7 @@ d2i_ECPrivateKey(EC_KEY **a, const unsigned char **in, long len)
 
         return (NULL);
 }
+LCRYPTO_ALIAS(d2i_ECPrivateKey);
 
 int
 i2d_ECPrivateKey(EC_KEY *a, unsigned char **out)
@@ -1297,6 +1315,7 @@ i2d_ECPrivateKey(EC_KEY *a, unsigned char **out)
                 EC_PRIVATEKEY_free(priv_key);
         return (ok ? ret : 0);
 }
+LCRYPTO_ALIAS(i2d_ECPrivateKey);
 
 int
 i2d_ECParameters(EC_KEY *a, unsigned char **out)
@@ -1307,6 +1326,7 @@ i2d_ECParameters(EC_KEY *a, unsigned char **out)
         }
         return i2d_ECPKParameters(a->group, out);
 }
+LCRYPTO_ALIAS(i2d_ECParameters);
 
 EC_KEY *
 d2i_ECParameters(EC_KEY **a, const unsigned char **in, long len)
@@ -1336,6 +1356,7 @@ d2i_ECParameters(EC_KEY **a, const unsigned char **in, long len)
                 *a = ret;
         return ret;
 }
+LCRYPTO_ALIAS(d2i_ECParameters);
 
 EC_KEY *
 o2i_ECPublicKey(EC_KEY **a, const unsigned char **in, long len)
@@ -1362,6 +1383,7 @@ o2i_ECPublicKey(EC_KEY **a, const unsigned char **in, long len)
         *in += len;
         return ret;
 }
+LCRYPTO_ALIAS(o2i_ECPublicKey);
 
 int
 i2o_ECPublicKey(const EC_KEY *a, unsigned char **out)
@@ -1400,3 +1422,4 @@ i2o_ECPublicKey(const EC_KEY *a, unsigned char **out)
                 *out += buf_len;
         return buf_len;
 }
+LCRYPTO_ALIAS(i2o_ECPublicKey);
diff --git a/src/lib/libcrypto/ec/ec_check.c b/src/lib/libcrypto/ec/ec_check.c
index 4a38dec539..0f98ef613c 100644
--- a/src/lib/libcrypto/ec/ec_check.c
+++ b/src/lib/libcrypto/ec/ec_check.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: ec_check.c,v 1.14 2023/07/03 09:29:55 tb Exp $ */
+/* $OpenBSD: ec_check.c,v 1.15 2023/07/07 13:54:45 beck Exp $ */
 /* ====================================================================
  * Copyright (c) 1998-2002 The OpenSSL Project.  All rights reserved.
  *
@@ -109,3 +109,4 @@ EC_GROUP_check(const EC_GROUP *group, BN_CTX *ctx_in)
 
         return ret;
 }
+LCRYPTO_ALIAS(EC_GROUP_check);
diff --git a/src/lib/libcrypto/ec/ec_curve.c b/src/lib/libcrypto/ec/ec_curve.c
index a8a1e4d522..9d19628b3e 100644
--- a/src/lib/libcrypto/ec/ec_curve.c
+++ b/src/lib/libcrypto/ec/ec_curve.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: ec_curve.c,v 1.41 2023/05/02 13:01:57 tb Exp $ */
+/* $OpenBSD: ec_curve.c,v 1.42 2023/07/07 13:54:45 beck Exp $ */
 /*
  * Written by Nils Larsch for the OpenSSL project.
  */
@@ -3122,6 +3122,7 @@ EC_GROUP_new_by_curve_name(int nid)
         ECerror(EC_R_UNKNOWN_GROUP);
         return NULL;
 }
+LCRYPTO_ALIAS(EC_GROUP_new_by_curve_name);
 
 size_t
 EC_get_builtin_curves(EC_builtin_curve *r, size_t nitems)
@@ -3140,6 +3141,7 @@ EC_get_builtin_curves(EC_builtin_curve *r, size_t nitems)
 
         return CURVE_LIST_LENGTH;
 }
+LCRYPTO_ALIAS(EC_get_builtin_curves);
 
 static const struct {
         const char *name;
@@ -3174,6 +3176,7 @@ EC_curve_nid2nist(int nid)
 
         return NULL;
 }
+LCRYPTO_ALIAS(EC_curve_nid2nist);
 
 int
 EC_curve_nist2nid(const char *name)
@@ -3187,3 +3190,4 @@ EC_curve_nist2nid(const char *name)
 
         return NID_undef;
 }
+LCRYPTO_ALIAS(EC_curve_nist2nid);
diff --git a/src/lib/libcrypto/ec/ec_cvt.c b/src/lib/libcrypto/ec/ec_cvt.c
index 90e7400739..5b196dd671 100644
--- a/src/lib/libcrypto/ec/ec_cvt.c
+++ b/src/lib/libcrypto/ec/ec_cvt.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: ec_cvt.c,v 1.11 2023/04/25 19:53:30 tb Exp $ */
+/* $OpenBSD: ec_cvt.c,v 1.12 2023/07/07 13:54:45 beck Exp $ */
 /*
  * Originally written by Bodo Moeller for the OpenSSL project.
  */
@@ -100,3 +100,4 @@ EC_GROUP_new_curve_GFp(const BIGNUM *p, const BIGNUM *a, const BIGNUM *b,
 {
         return ec_group_new_curve(EC_GFp_mont_method(), p, a, b, ctx);
 }
+LCRYPTO_ALIAS(EC_GROUP_new_curve_GFp);
diff --git a/src/lib/libcrypto/ec/ec_err.c b/src/lib/libcrypto/ec/ec_err.c
index d10b8e6f7d..d797b937c2 100644
--- a/src/lib/libcrypto/ec/ec_err.c
+++ b/src/lib/libcrypto/ec/ec_err.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: ec_err.c,v 1.16 2023/07/05 17:10:10 tb Exp $ */
+/* $OpenBSD: ec_err.c,v 1.17 2023/07/07 13:54:45 beck Exp $ */
 /* ====================================================================
  * Copyright (c) 1999-2011 The OpenSSL Project.  All rights reserved.
  *
@@ -147,3 +147,4 @@ ERR_load_EC_strings(void)
         }
 #endif
 }
+LCRYPTO_ALIAS(ERR_load_EC_strings);
diff --git a/src/lib/libcrypto/ec/ec_key.c b/src/lib/libcrypto/ec/ec_key.c
index a15d06b019..e5ff189803 100644
--- a/src/lib/libcrypto/ec/ec_key.c
+++ b/src/lib/libcrypto/ec/ec_key.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: ec_key.c,v 1.35 2023/07/05 08:39:40 tb Exp $ */
+/* $OpenBSD: ec_key.c,v 1.36 2023/07/07 13:54:45 beck Exp $ */
 /*
  * Written by Nils Larsch for the OpenSSL project.
  */
@@ -78,6 +78,7 @@ EC_KEY_new(void)
 {
         return EC_KEY_new_method(NULL);
 }
+LCRYPTO_ALIAS(EC_KEY_new);
 
 EC_KEY *
 EC_KEY_new_by_curve_name(int nid)
@@ -97,6 +98,7 @@ EC_KEY_new_by_curve_name(int nid)
         }
         return ret;
 }
+LCRYPTO_ALIAS(EC_KEY_new_by_curve_name);
 
 void
 EC_KEY_free(EC_KEY *r)
@@ -124,6 +126,7 @@ EC_KEY_free(EC_KEY *r)
 
         freezero(r, sizeof(EC_KEY));
 }
+LCRYPTO_ALIAS(EC_KEY_free);
 
 EC_KEY *
 EC_KEY_copy(EC_KEY *dest, const EC_KEY *src)
@@ -197,6 +200,7 @@ EC_KEY_copy(EC_KEY *dest, const EC_KEY *src)
 
         return dest;
 }
+LCRYPTO_ALIAS(EC_KEY_copy);
 
 EC_KEY *
 EC_KEY_dup(const EC_KEY *ec_key)
@@ -211,6 +215,7 @@ EC_KEY_dup(const EC_KEY *ec_key)
         }
         return ret;
 }
+LCRYPTO_ALIAS(EC_KEY_dup);
 
 int
 EC_KEY_up_ref(EC_KEY *r)
@@ -218,18 +223,21 @@ EC_KEY_up_ref(EC_KEY *r)
         int i = CRYPTO_add(&r->references, 1, CRYPTO_LOCK_EC);
         return ((i > 1) ? 1 : 0);
 }
+LCRYPTO_ALIAS(EC_KEY_up_ref);
 
 int
 EC_KEY_set_ex_data(EC_KEY *r, int idx, void *arg)
 {
         return CRYPTO_set_ex_data(&r->ex_data, idx, arg);
 }
+LCRYPTO_ALIAS(EC_KEY_set_ex_data);
 
 void *
 EC_KEY_get_ex_data(const EC_KEY *r, int idx)
 {
         return CRYPTO_get_ex_data(&r->ex_data, idx);
 }
+LCRYPTO_ALIAS(EC_KEY_get_ex_data);
 
 int
 EC_KEY_generate_key(EC_KEY *eckey)
@@ -239,6 +247,7 @@ EC_KEY_generate_key(EC_KEY *eckey)
         ECerror(EC_R_NOT_IMPLEMENTED);
         return 0;
 }
+LCRYPTO_ALIAS(EC_KEY_generate_key);
 
 int
 ec_key_gen(EC_KEY *eckey)
@@ -355,6 +364,7 @@ EC_KEY_check_key(const EC_KEY *eckey)
 
         return ret;
 }
+LCRYPTO_ALIAS(EC_KEY_check_key);
 
 int
 EC_KEY_set_public_key_affine_coordinates(EC_KEY *key, BIGNUM *x, BIGNUM *y)
@@ -409,12 +419,14 @@ EC_KEY_set_public_key_affine_coordinates(EC_KEY *key, BIGNUM *x, BIGNUM *y)
 
         return ret;
 }
+LCRYPTO_ALIAS(EC_KEY_set_public_key_affine_coordinates);
 
 const EC_GROUP *
 EC_KEY_get0_group(const EC_KEY *key)
 {
         return key->group;
 }
+LCRYPTO_ALIAS(EC_KEY_get0_group);
 
 int
 EC_KEY_set_group(EC_KEY *key, const EC_GROUP *group)
@@ -426,12 +438,14 @@ EC_KEY_set_group(EC_KEY *key, const EC_GROUP *group)
         key->group = EC_GROUP_dup(group);
         return (key->group == NULL) ? 0 : 1;
 }
+LCRYPTO_ALIAS(EC_KEY_set_group);
 
 const BIGNUM *
 EC_KEY_get0_private_key(const EC_KEY *key)
 {
         return key->priv_key;
 }
+LCRYPTO_ALIAS(EC_KEY_get0_private_key);
 
 int
 EC_KEY_set_private_key(EC_KEY *key, const BIGNUM *priv_key)
@@ -446,12 +460,14 @@ EC_KEY_set_private_key(EC_KEY *key, const BIGNUM *priv_key)
 
         return 1;
 }
+LCRYPTO_ALIAS(EC_KEY_set_private_key);
 
 const EC_POINT *
 EC_KEY_get0_public_key(const EC_KEY *key)
 {
         return key->pub_key;
 }
+LCRYPTO_ALIAS(EC_KEY_get0_public_key);
 
 int
 EC_KEY_set_public_key(EC_KEY *key, const EC_POINT *pub_key)
@@ -466,24 +482,28 @@ EC_KEY_set_public_key(EC_KEY *key, const EC_POINT *pub_key)
 
         return 1;
 }
+LCRYPTO_ALIAS(EC_KEY_set_public_key);
 
 unsigned int
 EC_KEY_get_enc_flags(const EC_KEY *key)
 {
         return key->enc_flag;
 }
+LCRYPTO_ALIAS(EC_KEY_get_enc_flags);
 
 void
 EC_KEY_set_enc_flags(EC_KEY *key, unsigned int flags)
 {
         key->enc_flag = flags;
 }
+LCRYPTO_ALIAS(EC_KEY_set_enc_flags);
 
 point_conversion_form_t
 EC_KEY_get_conv_form(const EC_KEY *key)
 {
         return key->conv_form;
 }
+LCRYPTO_ALIAS(EC_KEY_get_conv_form);
 
 void
 EC_KEY_set_conv_form(EC_KEY *key, point_conversion_form_t cform)
@@ -492,6 +512,7 @@ EC_KEY_set_conv_form(EC_KEY *key, point_conversion_form_t cform)
         if (key->group != NULL)
                 EC_GROUP_set_point_conversion_form(key->group, cform);
 }
+LCRYPTO_ALIAS(EC_KEY_set_conv_form);
 
 void
 EC_KEY_set_asn1_flag(EC_KEY *key, int flag)
@@ -499,6 +520,7 @@ EC_KEY_set_asn1_flag(EC_KEY *key, int flag)
         if (key->group != NULL)
                 EC_GROUP_set_asn1_flag(key->group, flag);
 }
+LCRYPTO_ALIAS(EC_KEY_set_asn1_flag);
 
 int
 EC_KEY_precompute_mult(EC_KEY *key, BN_CTX *ctx)
@@ -507,21 +529,25 @@ EC_KEY_precompute_mult(EC_KEY *key, BN_CTX *ctx)
                 return 0;
         return EC_GROUP_precompute_mult(key->group, ctx);
 }
+LCRYPTO_ALIAS(EC_KEY_precompute_mult);
 
 int
 EC_KEY_get_flags(const EC_KEY *key)
 {
         return key->flags;
 }
+LCRYPTO_ALIAS(EC_KEY_get_flags);
 
 void
 EC_KEY_set_flags(EC_KEY *key, int flags)
 {
         key->flags |= flags;
 }
+LCRYPTO_ALIAS(EC_KEY_set_flags);
 
 void
 EC_KEY_clear_flags(EC_KEY *key, int flags)
 {
         key->flags &= ~flags;
 }
+LCRYPTO_ALIAS(EC_KEY_clear_flags);
diff --git a/src/lib/libcrypto/ec/ec_kmeth.c b/src/lib/libcrypto/ec/ec_kmeth.c
index ec45e679d9..3e997f8a5e 100644
--- a/src/lib/libcrypto/ec/ec_kmeth.c
+++ b/src/lib/libcrypto/ec/ec_kmeth.c
@@ -1,4 +1,4 @@
-/*      $OpenBSD: ec_kmeth.c,v 1.10 2023/07/05 11:37:46 tb Exp $        */
+/*      $OpenBSD: ec_kmeth.c,v 1.11 2023/07/07 13:54:45 beck Exp $      */
 /*
  * Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
  * project.
@@ -92,12 +92,14 @@ EC_KEY_OpenSSL(void)
 {
         return &openssl_ec_key_method;
 }
+LCRYPTO_ALIAS(EC_KEY_OpenSSL);
 
 const EC_KEY_METHOD *
 EC_KEY_get_default_method(void)
 {
         return default_ec_key_meth;
 }
+LCRYPTO_ALIAS(EC_KEY_get_default_method);
 
 void
 EC_KEY_set_default_method(const EC_KEY_METHOD *meth)
@@ -107,12 +109,14 @@ EC_KEY_set_default_method(const EC_KEY_METHOD *meth)
         else
                 default_ec_key_meth = meth;
 }
+LCRYPTO_ALIAS(EC_KEY_set_default_method);
 
 const EC_KEY_METHOD *
 EC_KEY_get_method(const EC_KEY *key)
 {
         return key->meth;
 }
+LCRYPTO_ALIAS(EC_KEY_get_method);
 
 int
 EC_KEY_set_method(EC_KEY *key, const EC_KEY_METHOD *meth)
@@ -132,6 +136,7 @@ EC_KEY_set_method(EC_KEY *key, const EC_KEY_METHOD *meth)
                 return meth->init(key);
         return 1;
 }
+LCRYPTO_ALIAS(EC_KEY_set_method);
 
 EC_KEY *
 EC_KEY_new_method(ENGINE *engine)
@@ -180,6 +185,7 @@ EC_KEY_new_method(ENGINE *engine)
         EC_KEY_free(ret);
         return NULL;
 }
+LCRYPTO_ALIAS(EC_KEY_new_method);
 
 EC_KEY_METHOD *
 EC_KEY_METHOD_new(const EC_KEY_METHOD *meth)
@@ -193,6 +199,7 @@ EC_KEY_METHOD_new(const EC_KEY_METHOD *meth)
         ret->flags |= EC_KEY_METHOD_DYNAMIC;
         return ret;
 }
+LCRYPTO_ALIAS(EC_KEY_METHOD_new);
 
 void
 EC_KEY_METHOD_free(EC_KEY_METHOD *meth)
@@ -202,6 +209,7 @@ EC_KEY_METHOD_free(EC_KEY_METHOD *meth)
         if (meth->flags & EC_KEY_METHOD_DYNAMIC)
                 free(meth);
 }
+LCRYPTO_ALIAS(EC_KEY_METHOD_free);
 
 void
 EC_KEY_METHOD_set_init(EC_KEY_METHOD *meth,
@@ -219,12 +227,14 @@ EC_KEY_METHOD_set_init(EC_KEY_METHOD *meth,
         meth->set_private = set_private;
         meth->set_public = set_public;
 }
+LCRYPTO_ALIAS(EC_KEY_METHOD_set_init);
 
 void
 EC_KEY_METHOD_set_keygen(EC_KEY_METHOD *meth, int (*keygen)(EC_KEY *key))
 {
         meth->keygen = keygen;
 }
+LCRYPTO_ALIAS(EC_KEY_METHOD_set_keygen);
 
 void
 EC_KEY_METHOD_set_compute_key(EC_KEY_METHOD *meth,
@@ -233,6 +243,7 @@ EC_KEY_METHOD_set_compute_key(EC_KEY_METHOD *meth,
 {
         meth->compute_key = ckey;
 }
+LCRYPTO_ALIAS(EC_KEY_METHOD_set_compute_key);
 
 void
 EC_KEY_METHOD_set_sign(EC_KEY_METHOD *meth,
@@ -249,6 +260,7 @@ EC_KEY_METHOD_set_sign(EC_KEY_METHOD *meth,
         meth->sign_setup = sign_setup;
         meth->sign_sig = sign_sig;
 }
+LCRYPTO_ALIAS(EC_KEY_METHOD_set_sign);
 
 void
 EC_KEY_METHOD_set_verify(EC_KEY_METHOD *meth,
@@ -260,6 +272,7 @@ EC_KEY_METHOD_set_verify(EC_KEY_METHOD *meth,
         meth->verify = verify;
         meth->verify_sig = verify_sig;
 }
+LCRYPTO_ALIAS(EC_KEY_METHOD_set_verify);
 
 
 void
@@ -284,6 +297,7 @@ EC_KEY_METHOD_get_init(const EC_KEY_METHOD *meth,
         if (pset_public != NULL)
                 *pset_public = meth->set_public;
 }
+LCRYPTO_ALIAS(EC_KEY_METHOD_get_init);
 
 void
 EC_KEY_METHOD_get_keygen(const EC_KEY_METHOD *meth,
@@ -292,6 +306,7 @@ EC_KEY_METHOD_get_keygen(const EC_KEY_METHOD *meth,
         if (pkeygen != NULL)
                 *pkeygen = meth->keygen;
 }
+LCRYPTO_ALIAS(EC_KEY_METHOD_get_keygen);
 
 void
 EC_KEY_METHOD_get_compute_key(const EC_KEY_METHOD *meth,
@@ -301,6 +316,7 @@ EC_KEY_METHOD_get_compute_key(const EC_KEY_METHOD *meth,
         if (pck != NULL)
                 *pck = meth->compute_key;
 }
+LCRYPTO_ALIAS(EC_KEY_METHOD_get_compute_key);
 
 void
 EC_KEY_METHOD_get_sign(const EC_KEY_METHOD *meth,
@@ -320,6 +336,7 @@ EC_KEY_METHOD_get_sign(const EC_KEY_METHOD *meth,
         if (psign_sig != NULL)
                 *psign_sig = meth->sign_sig;
 }
+LCRYPTO_ALIAS(EC_KEY_METHOD_get_sign);
 
 void
 EC_KEY_METHOD_get_verify(const EC_KEY_METHOD *meth,
@@ -333,3 +350,4 @@ EC_KEY_METHOD_get_verify(const EC_KEY_METHOD *meth,
         if (pverify_sig != NULL)
                 *pverify_sig = meth->verify_sig;
 }
+LCRYPTO_ALIAS(EC_KEY_METHOD_get_verify);
diff --git a/src/lib/libcrypto/ec/ec_lib.c b/src/lib/libcrypto/ec/ec_lib.c
index 8cea0bb95b..3db1ca2f07 100644
--- a/src/lib/libcrypto/ec/ec_lib.c
+++ b/src/lib/libcrypto/ec/ec_lib.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: ec_lib.c,v 1.62 2023/07/03 07:26:40 tb Exp $ */
+/* $OpenBSD: ec_lib.c,v 1.63 2023/07/07 13:54:45 beck Exp $ */
 /*
  * Originally written by Bodo Moeller for the OpenSSL project.
  */
@@ -110,6 +110,7 @@ EC_GROUP_new(const EC_METHOD *meth)
         }
         return ret;
 }
+LCRYPTO_ALIAS(EC_GROUP_new);
 
 
 void
@@ -128,12 +129,14 @@ EC_GROUP_free(EC_GROUP *group)
         freezero(group->seed, group->seed_len);
         freezero(group, sizeof *group);
 }
+LCRYPTO_ALIAS(EC_GROUP_free);
 
 void
 EC_GROUP_clear_free(EC_GROUP *group)
 {
         EC_GROUP_free(group);
 }
+LCRYPTO_ALIAS(EC_GROUP_clear_free);
 
 int
 EC_GROUP_copy(EC_GROUP *dest, const EC_GROUP *src)
@@ -188,6 +191,7 @@ EC_GROUP_copy(EC_GROUP *dest, const EC_GROUP *src)
 
         return dest->meth->group_copy(dest, src);
 }
+LCRYPTO_ALIAS(EC_GROUP_copy);
 
 
 EC_GROUP *
@@ -202,6 +206,7 @@ EC_GROUP_dup(const EC_GROUP *a)
         }
         return t;
 }
+LCRYPTO_ALIAS(EC_GROUP_dup);
 
 
 const EC_METHOD *
@@ -209,6 +214,7 @@ EC_GROUP_method_of(const EC_GROUP *group)
 {
         return group->meth;
 }
+LCRYPTO_ALIAS(EC_GROUP_method_of);
 
 
 int
@@ -216,6 +222,7 @@ EC_METHOD_get_field_type(const EC_METHOD *meth)
 {
         return meth->field_type;
 }
+LCRYPTO_ALIAS(EC_METHOD_get_field_type);
 
 /*
  * If there is a user-provided cofactor, sanity check and use it. Otherwise
@@ -349,6 +356,7 @@ EC_GROUP_set_generator(EC_GROUP *group, const EC_POINT *generator,
 
         return 1;
 }
+LCRYPTO_ALIAS(EC_GROUP_set_generator);
 
 
 const EC_POINT *
@@ -356,6 +364,7 @@ EC_GROUP_get0_generator(const EC_GROUP *group)
 {
         return group->generator;
 }
+LCRYPTO_ALIAS(EC_GROUP_get0_generator);
 
 int
 EC_GROUP_get_order(const EC_GROUP *group, BIGNUM *order, BN_CTX *ctx)
@@ -365,6 +374,7 @@ EC_GROUP_get_order(const EC_GROUP *group, BIGNUM *order, BN_CTX *ctx)
 
         return !BN_is_zero(order);
 }
+LCRYPTO_ALIAS(EC_GROUP_get_order);
 
 const BIGNUM *
 EC_GROUP_get0_order(const EC_GROUP *group)
@@ -377,6 +387,7 @@ EC_GROUP_order_bits(const EC_GROUP *group)
 {
         return group->meth->group_order_bits(group);
 }
+LCRYPTO_ALIAS(EC_GROUP_order_bits);
 
 int
 EC_GROUP_get_cofactor(const EC_GROUP *group, BIGNUM *cofactor, BN_CTX *ctx)
@@ -386,6 +397,7 @@ EC_GROUP_get_cofactor(const EC_GROUP *group, BIGNUM *cofactor, BN_CTX *ctx)
 
         return !BN_is_zero(&group->cofactor);
 }
+LCRYPTO_ALIAS(EC_GROUP_get_cofactor);
 
 
 void
@@ -393,6 +405,7 @@ EC_GROUP_set_curve_name(EC_GROUP *group, int nid)
 {
         group->curve_name = nid;
 }
+LCRYPTO_ALIAS(EC_GROUP_set_curve_name);
 
 
 int
@@ -400,6 +413,7 @@ EC_GROUP_get_curve_name(const EC_GROUP *group)
 {
         return group->curve_name;
 }
+LCRYPTO_ALIAS(EC_GROUP_get_curve_name);
 
 
 void
@@ -407,6 +421,7 @@ EC_GROUP_set_asn1_flag(EC_GROUP *group, int flag)
 {
         group->asn1_flag = flag;
 }
+LCRYPTO_ALIAS(EC_GROUP_set_asn1_flag);
 
 
 int
@@ -414,6 +429,7 @@ EC_GROUP_get_asn1_flag(const EC_GROUP *group)
 {
         return group->asn1_flag;
 }
+LCRYPTO_ALIAS(EC_GROUP_get_asn1_flag);
 
 
 void
@@ -422,6 +438,7 @@ EC_GROUP_set_point_conversion_form(EC_GROUP *group,
 {
         group->asn1_form = form;
 }
+LCRYPTO_ALIAS(EC_GROUP_set_point_conversion_form);
 
 
 point_conversion_form_t
@@ -429,6 +446,7 @@ EC_GROUP_get_point_conversion_form(const EC_GROUP *group)
 {
         return group->asn1_form;
 }
+LCRYPTO_ALIAS(EC_GROUP_get_point_conversion_form);
 
 
 size_t
@@ -449,6 +467,7 @@ EC_GROUP_set_seed(EC_GROUP *group, const unsigned char *p, size_t len)
 
         return len;
 }
+LCRYPTO_ALIAS(EC_GROUP_set_seed);
 
 
 unsigned char *
@@ -456,6 +475,7 @@ EC_GROUP_get0_seed(const EC_GROUP *group)
 {
         return group->seed;
 }
+LCRYPTO_ALIAS(EC_GROUP_get0_seed);
 
 
 size_t
@@ -463,6 +483,7 @@ EC_GROUP_get_seed_len(const EC_GROUP *group)
 {
         return group->seed_len;
 }
+LCRYPTO_ALIAS(EC_GROUP_get_seed_len);
 
 int
 EC_GROUP_set_curve(EC_GROUP *group, const BIGNUM *p, const BIGNUM *a,
@@ -488,6 +509,7 @@ EC_GROUP_set_curve(EC_GROUP *group, const BIGNUM *p, const BIGNUM *a,
 
         return ret;
 }
+LCRYPTO_ALIAS(EC_GROUP_set_curve);
 
 int
 EC_GROUP_get_curve(const EC_GROUP *group, BIGNUM *p, BIGNUM *a, BIGNUM *b,
@@ -513,6 +535,7 @@ EC_GROUP_get_curve(const EC_GROUP *group, BIGNUM *p, BIGNUM *a, BIGNUM *b,
 
         return ret;
 }
+LCRYPTO_ALIAS(EC_GROUP_get_curve);
 
 int
 EC_GROUP_set_curve_GFp(EC_GROUP *group, const BIGNUM *p, const BIGNUM *a,
@@ -520,6 +543,7 @@ EC_GROUP_set_curve_GFp(EC_GROUP *group, const BIGNUM *p, const BIGNUM *a,
 {
         return EC_GROUP_set_curve(group, p, a, b, ctx);
 }
+LCRYPTO_ALIAS(EC_GROUP_set_curve_GFp);
 
 int
 EC_GROUP_get_curve_GFp(const EC_GROUP *group, BIGNUM *p, BIGNUM *a, BIGNUM *b,
@@ -527,6 +551,7 @@ EC_GROUP_get_curve_GFp(const EC_GROUP *group, BIGNUM *p, BIGNUM *a, BIGNUM *b,
 {
         return EC_GROUP_get_curve(group, p, a, b, ctx);
 }
+LCRYPTO_ALIAS(EC_GROUP_get_curve_GFp);
 
 int
 EC_GROUP_get_degree(const EC_GROUP *group)
@@ -537,6 +562,7 @@ EC_GROUP_get_degree(const EC_GROUP *group)
         }
         return group->meth->group_get_degree(group);
 }
+LCRYPTO_ALIAS(EC_GROUP_get_degree);
 
 
 int
@@ -562,6 +588,7 @@ EC_GROUP_check_discriminant(const EC_GROUP *group, BN_CTX *ctx_in)
 
         return ret;
 }
+LCRYPTO_ALIAS(EC_GROUP_check_discriminant);
 
 
 int
@@ -637,6 +664,7 @@ EC_GROUP_cmp(const EC_GROUP *a, const EC_GROUP *b, BN_CTX *ctx)
                 BN_CTX_free(ctx);
         return -1;
 }
+LCRYPTO_ALIAS(EC_GROUP_cmp);
 
 /*
  * Coordinate blinding for EC_POINT.
@@ -682,6 +710,7 @@ EC_POINT_new(const EC_GROUP *group)
         }
         return ret;
 }
+LCRYPTO_ALIAS(EC_POINT_new);
 
 void
 EC_POINT_free(EC_POINT *point)
@@ -694,12 +723,14 @@ EC_POINT_free(EC_POINT *point)
 
         freezero(point, sizeof *point);
 }
+LCRYPTO_ALIAS(EC_POINT_free);
 
 void
 EC_POINT_clear_free(EC_POINT *point)
 {
         EC_POINT_free(point);
 }
+LCRYPTO_ALIAS(EC_POINT_clear_free);
 
 int
 EC_POINT_copy(EC_POINT *dest, const EC_POINT *src)
@@ -716,6 +747,7 @@ EC_POINT_copy(EC_POINT *dest, const EC_POINT *src)
                 return 1;
         return dest->meth->point_copy(dest, src);
 }
+LCRYPTO_ALIAS(EC_POINT_copy);
 
 EC_POINT *
 EC_POINT_dup(const EC_POINT *a, const EC_GROUP *group)
@@ -736,12 +768,14 @@ EC_POINT_dup(const EC_POINT *a, const EC_GROUP *group)
         } else
                 return t;
 }
+LCRYPTO_ALIAS(EC_POINT_dup);
 
 const EC_METHOD *
 EC_POINT_method_of(const EC_POINT *point)
 {
         return point->meth;
 }
+LCRYPTO_ALIAS(EC_POINT_method_of);
 
 int
 EC_POINT_set_to_infinity(const EC_GROUP *group, EC_POINT *point)
@@ -756,6 +790,7 @@ EC_POINT_set_to_infinity(const EC_GROUP *group, EC_POINT *point)
         }
         return group->meth->point_set_to_infinity(group, point);
 }
+LCRYPTO_ALIAS(EC_POINT_set_to_infinity);
 
 int
 EC_POINT_set_Jprojective_coordinates(const EC_GROUP *group, EC_POINT *point,
@@ -831,6 +866,7 @@ EC_POINT_set_Jprojective_coordinates_GFp(const EC_GROUP *group, EC_POINT *point,
 {
         return EC_POINT_set_Jprojective_coordinates(group, point, x, y, z, ctx);
 }
+LCRYPTO_ALIAS(EC_POINT_set_Jprojective_coordinates_GFp);
 
 int
 EC_POINT_get_Jprojective_coordinates_GFp(const EC_GROUP *group,
@@ -838,6 +874,7 @@ EC_POINT_get_Jprojective_coordinates_GFp(const EC_GROUP *group,
 {
         return EC_POINT_get_Jprojective_coordinates(group, point, x, y, z, ctx);
 }
+LCRYPTO_ALIAS(EC_POINT_get_Jprojective_coordinates_GFp);
 
 int
 EC_POINT_set_affine_coordinates(const EC_GROUP *group, EC_POINT *point,
@@ -875,6 +912,7 @@ EC_POINT_set_affine_coordinates(const EC_GROUP *group, EC_POINT *point,
 
         return ret;
 }
+LCRYPTO_ALIAS(EC_POINT_set_affine_coordinates);
 
 int
 EC_POINT_set_affine_coordinates_GFp(const EC_GROUP *group, EC_POINT *point,
@@ -882,6 +920,7 @@ EC_POINT_set_affine_coordinates_GFp(const EC_GROUP *group, EC_POINT *point,
 {
         return EC_POINT_set_affine_coordinates(group, point, x, y, ctx);
 }
+LCRYPTO_ALIAS(EC_POINT_set_affine_coordinates_GFp);
 
 int
 EC_POINT_get_affine_coordinates(const EC_GROUP *group, const EC_POINT *point,
@@ -911,6 +950,7 @@ EC_POINT_get_affine_coordinates(const EC_GROUP *group, const EC_POINT *point,
 
         return ret;
 }
+LCRYPTO_ALIAS(EC_POINT_get_affine_coordinates);
 
 int
 EC_POINT_get_affine_coordinates_GFp(const EC_GROUP *group, const EC_POINT *point,
@@ -918,6 +958,7 @@ EC_POINT_get_affine_coordinates_GFp(const EC_GROUP *group, const EC_POINT *point
 {
         return EC_POINT_get_affine_coordinates(group, point, x, y, ctx);
 }
+LCRYPTO_ALIAS(EC_POINT_get_affine_coordinates_GFp);
 
 int
 EC_POINT_add(const EC_GROUP *group, EC_POINT *r, const EC_POINT *a,
@@ -948,6 +989,7 @@ EC_POINT_add(const EC_GROUP *group, EC_POINT *r, const EC_POINT *a,
 
         return ret;
 }
+LCRYPTO_ALIAS(EC_POINT_add);
 
 int
 EC_POINT_dbl(const EC_GROUP *group, EC_POINT *r, const EC_POINT *a,
@@ -977,6 +1019,7 @@ EC_POINT_dbl(const EC_GROUP *group, EC_POINT *r, const EC_POINT *a,
 
         return ret;
 }
+LCRYPTO_ALIAS(EC_POINT_dbl);
 
 int
 EC_POINT_invert(const EC_GROUP *group, EC_POINT *a, BN_CTX *ctx_in)
@@ -1005,6 +1048,7 @@ EC_POINT_invert(const EC_GROUP *group, EC_POINT *a, BN_CTX *ctx_in)
 
         return ret;
 }
+LCRYPTO_ALIAS(EC_POINT_invert);
 
 int
 EC_POINT_is_at_infinity(const EC_GROUP *group, const EC_POINT *point)
@@ -1019,6 +1063,7 @@ EC_POINT_is_at_infinity(const EC_GROUP *group, const EC_POINT *point)
         }
         return group->meth->is_at_infinity(group, point);
 }
+LCRYPTO_ALIAS(EC_POINT_is_at_infinity);
 
 int
 EC_POINT_is_on_curve(const EC_GROUP *group, const EC_POINT *point,
@@ -1048,6 +1093,7 @@ EC_POINT_is_on_curve(const EC_GROUP *group, const EC_POINT *point,
 
         return ret;
 }
+LCRYPTO_ALIAS(EC_POINT_is_on_curve);
 
 int
 EC_POINT_cmp(const EC_GROUP *group, const EC_POINT *a, const EC_POINT *b,
@@ -1077,6 +1123,7 @@ EC_POINT_cmp(const EC_GROUP *group, const EC_POINT *a, const EC_POINT *b,
 
         return ret;
 }
+LCRYPTO_ALIAS(EC_POINT_cmp);
 
 int
 EC_POINT_make_affine(const EC_GROUP *group, EC_POINT *point, BN_CTX *ctx_in)
@@ -1105,6 +1152,7 @@ EC_POINT_make_affine(const EC_GROUP *group, EC_POINT *point, BN_CTX *ctx_in)
 
         return ret;
 }
+LCRYPTO_ALIAS(EC_POINT_make_affine);
 
 int
 EC_POINTs_make_affine(const EC_GROUP *group, size_t num, EC_POINT *points[],
@@ -1137,6 +1185,7 @@ EC_POINTs_make_affine(const EC_GROUP *group, size_t num, EC_POINT *points[],
 
         return ret;
 }
+LCRYPTO_ALIAS(EC_POINTs_make_affine);
 
 int
 EC_POINTs_mul(const EC_GROUP *group, EC_POINT *r, const BIGNUM *scalar,
@@ -1178,6 +1227,7 @@ EC_POINTs_mul(const EC_GROUP *group, EC_POINT *r, const BIGNUM *scalar,
 
         return ret;
 }
+LCRYPTO_ALIAS(EC_POINTs_mul);
 
 int
 EC_POINT_mul(const EC_GROUP *group, EC_POINT *r, const BIGNUM *g_scalar,
@@ -1239,18 +1289,21 @@ EC_POINT_mul(const EC_GROUP *group, EC_POINT *r, const BIGNUM *g_scalar,
 
         return ret;
 }
+LCRYPTO_ALIAS(EC_POINT_mul);
 
 int
 EC_GROUP_precompute_mult(EC_GROUP *group, BN_CTX *ctx_in)
 {
         return 1;
 }
+LCRYPTO_ALIAS(EC_GROUP_precompute_mult);
 
 int
 EC_GROUP_have_precompute_mult(const EC_GROUP *group)
 {
         return 0;
 }
+LCRYPTO_ALIAS(EC_GROUP_have_precompute_mult);
 
 int
 ec_group_simple_order_bits(const EC_GROUP *group)
@@ -1283,3 +1336,4 @@ ECParameters_dup(EC_KEY *key)
 
         return dup;
 }
+LCRYPTO_ALIAS(ECParameters_dup);
diff --git a/src/lib/libcrypto/ec/ec_oct.c b/src/lib/libcrypto/ec/ec_oct.c
index f9de2f13a1..b9bc62a4e3 100644
--- a/src/lib/libcrypto/ec/ec_oct.c
+++ b/src/lib/libcrypto/ec/ec_oct.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: ec_oct.c,v 1.14 2023/05/04 06:45:51 tb Exp $ */
+/* $OpenBSD: ec_oct.c,v 1.15 2023/07/07 13:54:45 beck Exp $ */
 /*
  * Originally written by Bodo Moeller for the OpenSSL project.
  */
@@ -99,6 +99,7 @@ EC_POINT_set_compressed_coordinates(const EC_GROUP *group, EC_POINT *point,
 
         return ret;
 }
+LCRYPTO_ALIAS(EC_POINT_set_compressed_coordinates);
 
 int
 EC_POINT_set_compressed_coordinates_GFp(const EC_GROUP *group, EC_POINT *point,
@@ -106,6 +107,7 @@ EC_POINT_set_compressed_coordinates_GFp(const EC_GROUP *group, EC_POINT *point,
 {
         return EC_POINT_set_compressed_coordinates(group, point, x, y_bit, ctx);
 }
+LCRYPTO_ALIAS(EC_POINT_set_compressed_coordinates_GFp);
 
 size_t
 EC_POINT_point2oct(const EC_GROUP *group, const EC_POINT *point,
@@ -136,6 +138,7 @@ EC_POINT_point2oct(const EC_GROUP *group, const EC_POINT *point,
 
         return ret;
 }
+LCRYPTO_ALIAS(EC_POINT_point2oct);
 
 int
 EC_POINT_oct2point(const EC_GROUP *group, EC_POINT *point,
@@ -165,3 +168,4 @@ EC_POINT_oct2point(const EC_GROUP *group, EC_POINT *point,
 
         return ret;
 }
+LCRYPTO_ALIAS(EC_POINT_oct2point);
diff --git a/src/lib/libcrypto/ec/ec_print.c b/src/lib/libcrypto/ec/ec_print.c
index da33c4eccd..312770f66c 100644
--- a/src/lib/libcrypto/ec/ec_print.c
+++ b/src/lib/libcrypto/ec/ec_print.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: ec_print.c,v 1.12 2023/06/23 10:34:16 tb Exp $ */
+/* $OpenBSD: ec_print.c,v 1.13 2023/07/07 13:54:45 beck Exp $ */
 /* ====================================================================
  * Copyright (c) 1998-2002 The OpenSSL Project.  All rights reserved.
  *
@@ -81,6 +81,7 @@ EC_POINT_point2bn(const EC_GROUP *group, const EC_POINT *point,
 
         return ret;
 }
+LCRYPTO_ALIAS(EC_POINT_point2bn);
 
 EC_POINT *
 EC_POINT_bn2point(const EC_GROUP *group,
@@ -117,6 +118,7 @@ EC_POINT_bn2point(const EC_GROUP *group,
         free(buf);
         return ret;
 }
+LCRYPTO_ALIAS(EC_POINT_bn2point);
 
 static const char *HEX_DIGITS = "0123456789ABCDEF";
 
@@ -159,6 +161,7 @@ EC_POINT_point2hex(const EC_GROUP *group, const EC_POINT *point,
 
         return ret;
 }
+LCRYPTO_ALIAS(EC_POINT_point2hex);
 
 EC_POINT *
 EC_POINT_hex2point(const EC_GROUP *group, const char *buf,
@@ -176,3 +179,4 @@ EC_POINT_hex2point(const EC_GROUP *group, const char *buf,
 
         return ret;
 }
+LCRYPTO_ALIAS(EC_POINT_hex2point);
diff --git a/src/lib/libcrypto/ec/eck_prn.c b/src/lib/libcrypto/ec/eck_prn.c
index f65b74518b..6e89bfa739 100644
--- a/src/lib/libcrypto/ec/eck_prn.c
+++ b/src/lib/libcrypto/ec/eck_prn.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: eck_prn.c,v 1.27 2023/07/06 15:18:02 tb Exp $ */
+/* $OpenBSD: eck_prn.c,v 1.28 2023/07/07 13:54:45 beck Exp $ */
 /*
  * Written by Nils Larsch for the OpenSSL project.
  */
@@ -86,6 +86,7 @@ ECPKParameters_print_fp(FILE *fp, const EC_GROUP *x, int off)
         BIO_free(b);
         return (ret);
 }
+LCRYPTO_ALIAS(ECPKParameters_print_fp);
 
 int
 EC_KEY_print_fp(FILE *fp, const EC_KEY *x, int off)
@@ -102,6 +103,7 @@ EC_KEY_print_fp(FILE *fp, const EC_KEY *x, int off)
         BIO_free(b);
         return (ret);
 }
+LCRYPTO_ALIAS(EC_KEY_print_fp);
 
 int
 ECParameters_print_fp(FILE *fp, const EC_KEY *x)
@@ -118,6 +120,7 @@ ECParameters_print_fp(FILE *fp, const EC_KEY *x)
         BIO_free(b);
         return (ret);
 }
+LCRYPTO_ALIAS(ECParameters_print_fp);
 
 int
 EC_KEY_print(BIO *bp, const EC_KEY *x, int off)
@@ -136,6 +139,7 @@ EC_KEY_print(BIO *bp, const EC_KEY *x, int off)
         EVP_PKEY_free(pk);
         return ret;
 }
+LCRYPTO_ALIAS(EC_KEY_print);
 
 int
 ECParameters_print(BIO *bp, const EC_KEY *x)
@@ -154,6 +158,7 @@ ECParameters_print(BIO *bp, const EC_KEY *x)
         EVP_PKEY_free(pk);
         return ret;
 }
+LCRYPTO_ALIAS(ECParameters_print);
 
 static int
 print_bin(BIO *fp, const char *str, const unsigned char *num,
@@ -310,6 +315,7 @@ ECPKParameters_print(BIO *bp, const EC_GROUP *group, int off)
 
         return ecpk_print_explicit_parameters(bp, group, off);
 }
+LCRYPTO_ALIAS(ECPKParameters_print);
 
 static int
 print_bin(BIO *fp, const char *name, const unsigned char *buf,
diff --git a/src/lib/libcrypto/ec/ecp_mont.c b/src/lib/libcrypto/ec/ecp_mont.c
index b113855603..76d1f578ee 100644
--- a/src/lib/libcrypto/ec/ecp_mont.c
+++ b/src/lib/libcrypto/ec/ecp_mont.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: ecp_mont.c,v 1.29 2023/04/11 18:58:20 jsing Exp $ */
+/* $OpenBSD: ecp_mont.c,v 1.30 2023/07/07 13:54:45 beck Exp $ */
 /*
  * Originally written by Bodo Moeller for the OpenSSL project.
  */
@@ -269,3 +269,4 @@ EC_GFp_mont_method(void)
 {
         return &ec_GFp_mont_method;
 }
+LCRYPTO_ALIAS(EC_GFp_mont_method);
diff --git a/src/lib/libcrypto/ec/ecp_smpl.c b/src/lib/libcrypto/ec/ecp_smpl.c
index d3ee9f5d92..9aa9af11f3 100644
--- a/src/lib/libcrypto/ec/ecp_smpl.c
+++ b/src/lib/libcrypto/ec/ecp_smpl.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: ecp_smpl.c,v 1.45 2023/06/30 18:19:35 tb Exp $ */
+/* $OpenBSD: ecp_smpl.c,v 1.46 2023/07/07 13:54:45 beck Exp $ */
 /* Includes code written by Lenka Fibikova <fibikova@exp-math.uni-essen.de>
  * for the OpenSSL project.
  * Includes code written by Bodo Moeller for the OpenSSL project.
@@ -1604,3 +1604,4 @@ EC_GFp_simple_method(void)
 {
         return &ec_GFp_simple_method;
 }
+LCRYPTO_ALIAS(EC_GFp_simple_method);
diff --git a/src/lib/libcrypto/ecdh/ecdh.c b/src/lib/libcrypto/ecdh/ecdh.c
index 1179564030..0781c30e09 100644
--- a/src/lib/libcrypto/ecdh/ecdh.c
+++ b/src/lib/libcrypto/ecdh/ecdh.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: ecdh.c,v 1.3 2023/07/05 17:10:10 tb Exp $ */
+/* $OpenBSD: ecdh.c,v 1.4 2023/07/07 13:54:45 beck Exp $ */
 /* ====================================================================
  * Copyright 2002 Sun Microsystems, Inc. ALL RIGHTS RESERVED.
  *
@@ -264,9 +264,11 @@ ECDH_compute_key(void *out, size_t outlen, const EC_POINT *pub_key,
         }
         return eckey->meth->compute_key(out, outlen, pub_key, eckey, KDF);
 }
+LCRYPTO_ALIAS(ECDH_compute_key);
 
 int
 ECDH_size(const EC_KEY *d)
 {
         return (EC_GROUP_get_degree(EC_KEY_get0_group(d)) + 7) / 8;
 }
+LCRYPTO_ALIAS(ECDH_size);
diff --git a/src/lib/libcrypto/ecdh/ech_err.c b/src/lib/libcrypto/ecdh/ech_err.c
index e0cfddfe9c..1b194fe0fb 100644
--- a/src/lib/libcrypto/ecdh/ech_err.c
+++ b/src/lib/libcrypto/ecdh/ech_err.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: ech_err.c,v 1.7 2022/07/12 14:42:49 kn Exp $ */
+/* $OpenBSD: ech_err.c,v 1.8 2023/07/07 13:54:45 beck Exp $ */
 /* ====================================================================
  * Copyright (c) 1999-2011 The OpenSSL Project.  All rights reserved.
  *
@@ -91,3 +91,4 @@ ERR_load_ECDH_strings(void)
         }
 #endif
 }
+LCRYPTO_ALIAS(ERR_load_ECDH_strings);
diff --git a/src/lib/libcrypto/ecdh/ech_lib.c b/src/lib/libcrypto/ecdh/ech_lib.c
index 52019b01c1..c8e5744c0a 100644
--- a/src/lib/libcrypto/ecdh/ech_lib.c
+++ b/src/lib/libcrypto/ecdh/ech_lib.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: ech_lib.c,v 1.23 2023/07/05 08:39:40 tb Exp $ */
+/* $OpenBSD: ech_lib.c,v 1.24 2023/07/07 13:54:45 beck Exp $ */
 /* ====================================================================
  * Copyright 2002 Sun Microsystems, Inc. ALL RIGHTS RESERVED.
  *
@@ -98,12 +98,14 @@ ECDH_OpenSSL(void)
 {
         return &openssl_ecdh_meth;
 }
+LCRYPTO_ALIAS(ECDH_OpenSSL);
 
 void
 ECDH_set_default_method(const ECDH_METHOD *meth)
 {
         default_ECDH_method = meth;
 }
+LCRYPTO_ALIAS(ECDH_set_default_method);
 
 const ECDH_METHOD *
 ECDH_get_default_method(void)
@@ -113,12 +115,14 @@ ECDH_get_default_method(void)
         }
         return default_ECDH_method;
 }
+LCRYPTO_ALIAS(ECDH_get_default_method);
 
 int
 ECDH_set_method(EC_KEY *eckey, const ECDH_METHOD *meth)
 {
         return 0;
 }
+LCRYPTO_ALIAS(ECDH_set_method);
 
 int
 ECDH_get_ex_new_index(long argl, void *argp, CRYPTO_EX_new *new_func,
@@ -126,15 +130,18 @@ ECDH_get_ex_new_index(long argl, void *argp, CRYPTO_EX_new *new_func,
 {
         return -1;
 }
+LCRYPTO_ALIAS(ECDH_get_ex_new_index);
 
 int
 ECDH_set_ex_data(EC_KEY *d, int idx, void *arg)
 {
         return 0;
 }
+LCRYPTO_ALIAS(ECDH_set_ex_data);
 
 void *
 ECDH_get_ex_data(EC_KEY *d, int idx)
 {
         return NULL;
 }
+LCRYPTO_ALIAS(ECDH_get_ex_data);
diff --git a/src/lib/libcrypto/ecdsa/ecdsa.c b/src/lib/libcrypto/ecdsa/ecdsa.c
index b9c7ea6381..5a93b84637 100644
--- a/src/lib/libcrypto/ecdsa/ecdsa.c
+++ b/src/lib/libcrypto/ecdsa/ecdsa.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: ecdsa.c,v 1.10 2023/07/05 17:10:10 tb Exp $ */
+/* $OpenBSD: ecdsa.c,v 1.11 2023/07/07 13:54:45 beck Exp $ */
 /* ====================================================================
  * Copyright (c) 2000-2002 The OpenSSL Project.  All rights reserved.
  *
@@ -104,24 +104,28 @@ d2i_ECDSA_SIG(ECDSA_SIG **a, const unsigned char **in, long len)
         return (ECDSA_SIG *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
             &ECDSA_SIG_it);
 }
+LCRYPTO_ALIAS(d2i_ECDSA_SIG);
 
 int
 i2d_ECDSA_SIG(const ECDSA_SIG *a, unsigned char **out)
 {
         return ASN1_item_i2d((ASN1_VALUE *)a, out, &ECDSA_SIG_it);
 }
+LCRYPTO_ALIAS(i2d_ECDSA_SIG);
 
 ECDSA_SIG *
 ECDSA_SIG_new(void)
 {
         return (ECDSA_SIG *)ASN1_item_new(&ECDSA_SIG_it);
 }
+LCRYPTO_ALIAS(ECDSA_SIG_new);
 
 void
 ECDSA_SIG_free(ECDSA_SIG *a)
 {
         ASN1_item_free((ASN1_VALUE *)a, &ECDSA_SIG_it);
 }
+LCRYPTO_ALIAS(ECDSA_SIG_free);
 
 void
 ECDSA_SIG_get0(const ECDSA_SIG *sig, const BIGNUM **pr, const BIGNUM **ps)
@@ -131,18 +135,21 @@ ECDSA_SIG_get0(const ECDSA_SIG *sig, const BIGNUM **pr, const BIGNUM **ps)
         if (ps != NULL)
                 *ps = sig->s;
 }
+LCRYPTO_ALIAS(ECDSA_SIG_get0);
 
 const BIGNUM *
 ECDSA_SIG_get0_r(const ECDSA_SIG *sig)
 {
         return sig->r;
 }
+LCRYPTO_ALIAS(ECDSA_SIG_get0_r);
 
 const BIGNUM *
 ECDSA_SIG_get0_s(const ECDSA_SIG *sig)
 {
         return sig->s;
 }
+LCRYPTO_ALIAS(ECDSA_SIG_get0_s);
 
 int
 ECDSA_SIG_set0(ECDSA_SIG *sig, BIGNUM *r, BIGNUM *s)
@@ -156,6 +163,7 @@ ECDSA_SIG_set0(ECDSA_SIG *sig, BIGNUM *r, BIGNUM *s)
         sig->s = s;
         return 1;
 }
+LCRYPTO_ALIAS(ECDSA_SIG_set0);
 
 int
 ECDSA_size(const EC_KEY *r)
@@ -183,6 +191,7 @@ ECDSA_size(const EC_KEY *r)
  err:
         return ret;
 }
+LCRYPTO_ALIAS(ECDSA_size);
 
 /*
  * FIPS 186-5, section 6.4.1, step 2: convert hashed message into an integer.
@@ -751,6 +760,7 @@ ECDSA_do_sign(const unsigned char *digest, int digest_len, EC_KEY *key)
 {
         return ECDSA_do_sign_ex(digest, digest_len, NULL, NULL, key);
 }
+LCRYPTO_ALIAS(ECDSA_do_sign);
 
 ECDSA_SIG *
 ECDSA_do_sign_ex(const unsigned char *digest, int digest_len,
@@ -762,6 +772,7 @@ ECDSA_do_sign_ex(const unsigned char *digest, int digest_len,
         }
         return key->meth->sign_sig(digest, digest_len, kinv, out_r, key);
 }
+LCRYPTO_ALIAS(ECDSA_do_sign_ex);
 
 int
 ECDSA_sign(int type, const unsigned char *digest, int digest_len,
@@ -770,6 +781,7 @@ ECDSA_sign(int type, const unsigned char *digest, int digest_len,
         return ECDSA_sign_ex(type, digest, digest_len, signature, signature_len,
             NULL, NULL, key);
 }
+LCRYPTO_ALIAS(ECDSA_sign);
 
 int
 ECDSA_sign_ex(int type, const unsigned char *digest, int digest_len,
@@ -783,6 +795,7 @@ ECDSA_sign_ex(int type, const unsigned char *digest, int digest_len,
         return key->meth->sign(type, digest, digest_len, signature,
             signature_len, kinv, r, key);
 }
+LCRYPTO_ALIAS(ECDSA_sign_ex);
 
 int
 ECDSA_sign_setup(EC_KEY *key, BN_CTX *in_ctx, BIGNUM **out_kinv,
@@ -794,6 +807,7 @@ ECDSA_sign_setup(EC_KEY *key, BN_CTX *in_ctx, BIGNUM **out_kinv,
         }
         return key->meth->sign_setup(key, in_ctx, out_kinv, out_r);
 }
+LCRYPTO_ALIAS(ECDSA_sign_setup);
 
 int
 ECDSA_do_verify(const unsigned char *digest, int digest_len,
@@ -805,6 +819,7 @@ ECDSA_do_verify(const unsigned char *digest, int digest_len,
         }
         return key->meth->verify_sig(digest, digest_len, sig, key);
 }
+LCRYPTO_ALIAS(ECDSA_do_verify);
 
 int
 ECDSA_verify(int type, const unsigned char *digest, int digest_len,
@@ -816,3 +831,4 @@ ECDSA_verify(int type, const unsigned char *digest, int digest_len,
         }
         return key->meth->verify(type, digest, digest_len, sigbuf, sig_len, key);
 }
+LCRYPTO_ALIAS(ECDSA_verify);
diff --git a/src/lib/libcrypto/ecdsa/ecs_err.c b/src/lib/libcrypto/ecdsa/ecs_err.c
index c839c35221..54d2f3f6ef 100644
--- a/src/lib/libcrypto/ecdsa/ecs_err.c
+++ b/src/lib/libcrypto/ecdsa/ecs_err.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: ecs_err.c,v 1.7 2022/07/12 14:42:49 kn Exp $ */
+/* $OpenBSD: ecs_err.c,v 1.8 2023/07/07 13:54:45 beck Exp $ */
 /* ====================================================================
  * Copyright (c) 1999-2011 The OpenSSL Project.  All rights reserved.
  *
@@ -94,3 +94,4 @@ ERR_load_ECDSA_strings(void)
         }
 #endif
 }
+LCRYPTO_ALIAS(ERR_load_ECDSA_strings);
diff --git a/src/lib/libcrypto/ecdsa/ecs_lib.c b/src/lib/libcrypto/ecdsa/ecs_lib.c
index ed02b552c9..e3e67ba07d 100644
--- a/src/lib/libcrypto/ecdsa/ecs_lib.c
+++ b/src/lib/libcrypto/ecdsa/ecs_lib.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: ecs_lib.c,v 1.24 2023/07/05 11:37:46 tb Exp $ */
+/* $OpenBSD: ecs_lib.c,v 1.25 2023/07/07 13:54:45 beck Exp $ */
 /* ====================================================================
  * Copyright (c) 1998-2005 The OpenSSL Project.  All rights reserved.
  *
@@ -80,12 +80,14 @@ ECDSA_OpenSSL(void)
 {
         return &openssl_ecdsa_meth;
 }
+LCRYPTO_ALIAS(ECDSA_OpenSSL);
 
 void
 ECDSA_set_default_method(const ECDSA_METHOD *meth)
 {
         default_ECDSA_method = meth;
 }
+LCRYPTO_ALIAS(ECDSA_set_default_method);
 
 const ECDSA_METHOD *
 ECDSA_get_default_method(void)
@@ -95,12 +97,14 @@ ECDSA_get_default_method(void)
         }
         return default_ECDSA_method;
 }
+LCRYPTO_ALIAS(ECDSA_get_default_method);
 
 int
 ECDSA_set_method(EC_KEY *eckey, const ECDSA_METHOD *meth)
 {
         return 0;
 }
+LCRYPTO_ALIAS(ECDSA_set_method);
 
 int
 ECDSA_get_ex_new_index(long argl, void *argp, CRYPTO_EX_new *new_func,
@@ -108,15 +112,18 @@ ECDSA_get_ex_new_index(long argl, void *argp, CRYPTO_EX_new *new_func,
 {
         return -1;
 }
+LCRYPTO_ALIAS(ECDSA_get_ex_new_index);
 
 int
 ECDSA_set_ex_data(EC_KEY *d, int idx, void *arg)
 {
         return 0;
 }
+LCRYPTO_ALIAS(ECDSA_set_ex_data);
 
 void *
 ECDSA_get_ex_data(EC_KEY *d, int idx)
 {
         return NULL;
 }
+LCRYPTO_ALIAS(ECDSA_get_ex_data);
diff --git a/src/lib/libcrypto/err/err.c b/src/lib/libcrypto/err/err.c
index 365eae0e90..c513e45f9b 100644
--- a/src/lib/libcrypto/err/err.c
+++ b/src/lib/libcrypto/err/err.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: err.c,v 1.52 2023/04/09 19:10:23 tb Exp $ */
+/* $OpenBSD: err.c,v 1.53 2023/07/07 13:54:45 beck Exp $ */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
  * All rights reserved.
  *
@@ -308,6 +308,7 @@ ERR_get_implementation(void)
         err_fns_check();
         return err_fns;
 }
+LCRYPTO_ALIAS(ERR_get_implementation);
 
 int
 ERR_set_implementation(const ERR_FNS *fns)
@@ -324,6 +325,7 @@ ERR_set_implementation(const ERR_FNS *fns)
         CRYPTO_w_unlock(CRYPTO_LOCK_ERR);
         return ret;
 }
+LCRYPTO_ALIAS(ERR_set_implementation);
 
 /* These are the callbacks provided to "lh_new()" when creating the LHASH tables
  * internal to the "err_defaults" implementation. */
@@ -685,6 +687,7 @@ ERR_load_ERR_strings(void)
 
         (void) pthread_once(&once, ERR_load_ERR_strings_internal);
 }
+LCRYPTO_ALIAS(ERR_load_ERR_strings);
 
 static void
 err_load_strings(int lib, ERR_STRING_DATA *str)
@@ -703,6 +706,7 @@ ERR_load_strings(int lib, ERR_STRING_DATA *str)
         ERR_load_ERR_strings();
         err_load_strings(lib, str);
 }
+LCRYPTO_ALIAS(ERR_load_strings);
 
 void
 ERR_unload_strings(int lib, ERR_STRING_DATA *str)
@@ -717,6 +721,7 @@ ERR_unload_strings(int lib, ERR_STRING_DATA *str)
                 str++;
         }
 }
+LCRYPTO_ALIAS(ERR_unload_strings);
 
 void
 ERR_free_strings(void)
@@ -727,6 +732,7 @@ ERR_free_strings(void)
         err_fns_check();
         ERRFN(err_del)();
 }
+LCRYPTO_ALIAS(ERR_free_strings);
 
 /********************************************************/
 
@@ -748,6 +754,7 @@ ERR_put_error(int lib, int func, int reason, const char *file, int line)
         err_clear_data(es, es->top);
         errno = save_errno;
 }
+LCRYPTO_ALIAS(ERR_put_error);
 
 void
 ERR_clear_error(void)
@@ -762,6 +769,7 @@ ERR_clear_error(void)
         }
         es->top = es->bottom = 0;
 }
+LCRYPTO_ALIAS(ERR_clear_error);
 
 
 unsigned long
@@ -769,12 +777,14 @@ ERR_get_error(void)
 {
         return (get_error_values(1, 0, NULL, NULL, NULL, NULL));
 }
+LCRYPTO_ALIAS(ERR_get_error);
 
 unsigned long
 ERR_get_error_line(const char **file, int *line)
 {
         return (get_error_values(1, 0, file, line, NULL, NULL));
 }
+LCRYPTO_ALIAS(ERR_get_error_line);
 
 unsigned long
 ERR_get_error_line_data(const char **file, int *line,
@@ -782,6 +792,7 @@ ERR_get_error_line_data(const char **file, int *line,
 {
         return (get_error_values(1, 0, file, line, data, flags));
 }
+LCRYPTO_ALIAS(ERR_get_error_line_data);
 
 
 unsigned long
@@ -789,12 +800,14 @@ ERR_peek_error(void)
 {
         return (get_error_values(0, 0, NULL, NULL, NULL, NULL));
 }
+LCRYPTO_ALIAS(ERR_peek_error);
 
 unsigned long
 ERR_peek_error_line(const char **file, int *line)
 {
         return (get_error_values(0, 0, file, line, NULL, NULL));
 }
+LCRYPTO_ALIAS(ERR_peek_error_line);
 
 unsigned long
 ERR_peek_error_line_data(const char **file, int *line,
@@ -802,18 +815,21 @@ ERR_peek_error_line_data(const char **file, int *line,
 {
         return (get_error_values(0, 0, file, line, data, flags));
 }
+LCRYPTO_ALIAS(ERR_peek_error_line_data);
 
 unsigned long
 ERR_peek_last_error(void)
 {
         return (get_error_values(0, 1, NULL, NULL, NULL, NULL));
 }
+LCRYPTO_ALIAS(ERR_peek_last_error);
 
 unsigned long
 ERR_peek_last_error_line(const char **file, int *line)
 {
         return (get_error_values(0, 1, file, line, NULL, NULL));
 }
+LCRYPTO_ALIAS(ERR_peek_last_error_line);
 
 unsigned long
 ERR_peek_last_error_line_data(const char **file, int *line,
@@ -821,6 +837,7 @@ ERR_peek_last_error_line_data(const char **file, int *line,
 {
         return (get_error_values(0, 1, file, line, data, flags));
 }
+LCRYPTO_ALIAS(ERR_peek_last_error_line_data);
 
 static unsigned long
 get_error_values(int inc, int top, const char **file, int *line,
@@ -942,6 +959,7 @@ ERR_error_string_n(unsigned long e, char *buf, size_t len)
                 }
         }
 }
+LCRYPTO_ALIAS(ERR_error_string_n);
 
 /* BAD for multi-threading: uses a local buffer if ret == NULL */
 /* ERR_error_string_n should be used instead for ret != NULL
@@ -957,6 +975,7 @@ ERR_error_string(unsigned long e, char *ret)
 
         return ret;
 }
+LCRYPTO_ALIAS(ERR_error_string);
 
 LHASH_OF(ERR_STRING_DATA) *ERR_get_string_table(void)
 {
@@ -976,6 +995,7 @@ ERR_release_err_state_table(LHASH_OF(ERR_STATE) **hash)
         err_fns_check();
         ERRFN(thread_release)(hash);
 }
+LCRYPTO_ALIAS(ERR_release_err_state_table);
 
 const char *
 ERR_lib_error_string(unsigned long e)
@@ -992,6 +1012,7 @@ ERR_lib_error_string(unsigned long e)
         p = ERRFN(err_get_item)(&d);
         return ((p == NULL) ? NULL : p->string);
 }
+LCRYPTO_ALIAS(ERR_lib_error_string);
 
 const char *
 ERR_func_error_string(unsigned long e)
@@ -1006,6 +1027,7 @@ ERR_func_error_string(unsigned long e)
         p = ERRFN(err_get_item)(&d);
         return ((p == NULL) ? NULL : p->string);
 }
+LCRYPTO_ALIAS(ERR_func_error_string);
 
 const char *
 ERR_reason_error_string(unsigned long e)
@@ -1024,6 +1046,7 @@ ERR_reason_error_string(unsigned long e)
         }
         return ((p == NULL) ? NULL : p->string);
 }
+LCRYPTO_ALIAS(ERR_reason_error_string);
 
 void
 ERR_remove_thread_state(const CRYPTO_THREADID *id)
@@ -1039,12 +1062,14 @@ ERR_remove_thread_state(const CRYPTO_THREADID *id)
          * items reaches zero. */
         ERRFN(thread_del_item)(&tmp);
 }
+LCRYPTO_ALIAS(ERR_remove_thread_state);
 
 void
 ERR_remove_state(unsigned long pid)
 {
         ERR_remove_thread_state(NULL);
 }
+LCRYPTO_ALIAS(ERR_remove_state);
 
 ERR_STATE *
 ERR_get_state(void)
@@ -1084,6 +1109,7 @@ ERR_get_state(void)
         }
         return ret;
 }
+LCRYPTO_ALIAS(ERR_get_state);
 
 int
 ERR_get_next_error_library(void)
@@ -1091,6 +1117,7 @@ ERR_get_next_error_library(void)
         err_fns_check();
         return ERRFN(get_next_lib)();
 }
+LCRYPTO_ALIAS(ERR_get_next_error_library);
 
 void
 ERR_set_error_data(char *data, int flags)
@@ -1108,6 +1135,7 @@ ERR_set_error_data(char *data, int flags)
         es->err_data[i] = data;
         es->err_data_flags[i] = flags;
 }
+LCRYPTO_ALIAS(ERR_set_error_data);
 
 void
 ERR_asprintf_error_data(char * format, ...)
@@ -1124,6 +1152,7 @@ ERR_asprintf_error_data(char * format, ...)
         else
                 ERR_set_error_data(errbuf, ERR_TXT_MALLOCED|ERR_TXT_STRING);
 }
+LCRYPTO_ALIAS(ERR_asprintf_error_data);
 
 void
 ERR_add_error_vdata(int num, va_list args)
@@ -1144,6 +1173,7 @@ ERR_add_error_vdata(int num, va_list args)
         else
                 ERR_set_error_data(errbuf, ERR_TXT_MALLOCED|ERR_TXT_STRING);
 }
+LCRYPTO_ALIAS(ERR_add_error_vdata);
 
 void
 ERR_add_error_data(int num, ...)
@@ -1153,6 +1183,7 @@ ERR_add_error_data(int num, ...)
         ERR_add_error_vdata(num, args);
         va_end(args);
 }
+LCRYPTO_ALIAS(ERR_add_error_data);
 
 int
 ERR_set_mark(void)
@@ -1166,6 +1197,7 @@ ERR_set_mark(void)
         es->err_flags[es->top] |= ERR_FLAG_MARK;
         return 1;
 }
+LCRYPTO_ALIAS(ERR_set_mark);
 
 int
 ERR_pop_to_mark(void)
@@ -1187,6 +1219,7 @@ ERR_pop_to_mark(void)
         es->err_flags[es->top]&=~ERR_FLAG_MARK;
         return 1;
 }
+LCRYPTO_ALIAS(ERR_pop_to_mark);
 
 void
 err_clear_last_constant_time(int clear)
diff --git a/src/lib/libcrypto/err/err_all.c b/src/lib/libcrypto/err/err_all.c
index 9a46e93c24..12a0fcd329 100644
--- a/src/lib/libcrypto/err/err_all.c
+++ b/src/lib/libcrypto/err/err_all.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: err_all.c,v 1.28 2023/06/11 05:35:43 tb Exp $ */
+/* $OpenBSD: err_all.c,v 1.29 2023/07/07 13:54:45 beck Exp $ */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
  * All rights reserved.
  *
@@ -174,3 +174,4 @@ ERR_load_crypto_strings(void)
         static pthread_once_t loaded = PTHREAD_ONCE_INIT;
         (void) pthread_once(&loaded, ERR_load_crypto_strings_internal);
 }
+LCRYPTO_ALIAS(ERR_load_crypto_strings);
diff --git a/src/lib/libcrypto/err/err_prn.c b/src/lib/libcrypto/err/err_prn.c
index 6b5c455f06..d60cfdcb92 100644
--- a/src/lib/libcrypto/err/err_prn.c
+++ b/src/lib/libcrypto/err/err_prn.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: err_prn.c,v 1.19 2022/01/07 09:02:18 tb Exp $ */
+/* $OpenBSD: err_prn.c,v 1.20 2023/07/07 13:54:45 beck Exp $ */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
  * All rights reserved.
  *
@@ -88,6 +88,7 @@ ERR_print_errors_cb(int (*cb)(const char *str, size_t len, void *u), void *u)
                         break; /* abort outputting the error report */
         }
 }
+LCRYPTO_ALIAS(ERR_print_errors_cb);
 
 static int
 print_fp(const char *str, size_t len, void *fp)
@@ -105,6 +106,7 @@ ERR_print_errors_fp(FILE *fp)
 {
         ERR_print_errors_cb(print_fp, fp);
 }
+LCRYPTO_ALIAS(ERR_print_errors_fp);
 
 static int
 print_bio(const char *str, size_t len, void *bp)
@@ -117,3 +119,4 @@ ERR_print_errors(BIO *bp)
 {
         ERR_print_errors_cb(print_bio, bp);
 }
+LCRYPTO_ALIAS(ERR_print_errors);
diff --git a/src/lib/libcrypto/evp/bio_b64.c b/src/lib/libcrypto/evp/bio_b64.c
index 8880a28375..5eceda0993 100644
--- a/src/lib/libcrypto/evp/bio_b64.c
+++ b/src/lib/libcrypto/evp/bio_b64.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: bio_b64.c,v 1.26 2022/11/26 16:08:52 tb Exp $ */
+/* $OpenBSD: bio_b64.c,v 1.27 2023/07/07 13:54:45 beck Exp $ */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
  * All rights reserved.
  *
@@ -111,6 +111,7 @@ BIO_f_base64(void)
 {
         return (&methods_b64);
 }
+LCRYPTO_ALIAS(BIO_f_base64);
 
 static int
 b64_new(BIO *bi)
diff --git a/src/lib/libcrypto/evp/bio_enc.c b/src/lib/libcrypto/evp/bio_enc.c
index 098b1ea32b..747e64ed7f 100644
--- a/src/lib/libcrypto/evp/bio_enc.c
+++ b/src/lib/libcrypto/evp/bio_enc.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: bio_enc.c,v 1.27 2022/11/26 16:08:52 tb Exp $ */
+/* $OpenBSD: bio_enc.c,v 1.28 2023/07/07 13:54:45 beck Exp $ */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
  * All rights reserved.
  *
@@ -106,6 +106,7 @@ BIO_f_cipher(void)
 {
         return (&methods_enc);
 }
+LCRYPTO_ALIAS(BIO_f_cipher);
 
 static int
 enc_new(BIO *bi)
@@ -416,3 +417,4 @@ BIO_set_cipher(BIO *b, const EVP_CIPHER *c, const unsigned char *k,
 
         return 1;
 }
+LCRYPTO_ALIAS(BIO_set_cipher);
diff --git a/src/lib/libcrypto/evp/bio_md.c b/src/lib/libcrypto/evp/bio_md.c
index 4b7ca44551..83d6c3732c 100644
--- a/src/lib/libcrypto/evp/bio_md.c
+++ b/src/lib/libcrypto/evp/bio_md.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: bio_md.c,v 1.19 2022/11/26 16:08:52 tb Exp $ */
+/* $OpenBSD: bio_md.c,v 1.20 2023/07/07 13:54:45 beck Exp $ */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
  * All rights reserved.
  *
@@ -94,6 +94,7 @@ BIO_f_md(void)
 {
         return (&methods_md);
 }
+LCRYPTO_ALIAS(BIO_f_md);
 
 static int
 md_new(BIO *bi)
diff --git a/src/lib/libcrypto/evp/c_all.c b/src/lib/libcrypto/evp/c_all.c
index 936d7e810f..5efcd5f237 100644
--- a/src/lib/libcrypto/evp/c_all.c
+++ b/src/lib/libcrypto/evp/c_all.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: c_all.c,v 1.29 2023/04/25 15:48:48 tb Exp $ */
+/* $OpenBSD: c_all.c,v 1.30 2023/07/07 13:54:45 beck Exp $ */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
  * All rights reserved.
  *
@@ -251,6 +251,7 @@ OpenSSL_add_all_ciphers(void)
         static pthread_once_t add_all_ciphers_once = PTHREAD_ONCE_INIT;
         (void) pthread_once(&add_all_ciphers_once, OpenSSL_add_all_ciphers_internal);
 }
+LCRYPTO_ALIAS(OpenSSL_add_all_ciphers);
 
 static void
 OpenSSL_add_all_digests_internal(void)
@@ -313,6 +314,7 @@ OpenSSL_add_all_digests(void)
         static pthread_once_t add_all_digests_once = PTHREAD_ONCE_INIT;
         (void) pthread_once(&add_all_digests_once, OpenSSL_add_all_digests_internal);
 }
+LCRYPTO_ALIAS(OpenSSL_add_all_digests);
 
 void
 OPENSSL_add_all_algorithms_noconf(void)
@@ -321,6 +323,7 @@ OPENSSL_add_all_algorithms_noconf(void)
         OpenSSL_add_all_ciphers();
         OpenSSL_add_all_digests();
 }
+LCRYPTO_ALIAS(OPENSSL_add_all_algorithms_noconf);
 
 void
 OPENSSL_add_all_algorithms_conf(void)
@@ -328,3 +331,4 @@ OPENSSL_add_all_algorithms_conf(void)
         OPENSSL_add_all_algorithms_noconf();
         OPENSSL_config(NULL);
 }
+LCRYPTO_ALIAS(OPENSSL_add_all_algorithms_conf);
diff --git a/src/lib/libcrypto/evp/cipher_method_lib.c b/src/lib/libcrypto/evp/cipher_method_lib.c
index 55dc6b788c..9e4fd483a3 100644
--- a/src/lib/libcrypto/evp/cipher_method_lib.c
+++ b/src/lib/libcrypto/evp/cipher_method_lib.c
@@ -1,4 +1,4 @@
-/*      $OpenBSD: cipher_method_lib.c,v 1.8 2023/03/01 11:27:37 tb Exp $ */
+/*      $OpenBSD: cipher_method_lib.c,v 1.9 2023/07/07 13:54:45 beck Exp $ */
 /*
  * Written by Richard Levitte (levitte@openssl.org) for the OpenSSL project
  * 2015.
@@ -77,6 +77,7 @@ EVP_CIPHER_meth_new(int cipher_type, int block_size, int key_len)
 
         return cipher;
 }
+LCRYPTO_ALIAS(EVP_CIPHER_meth_new);
 
 EVP_CIPHER *
 EVP_CIPHER_meth_dup(const EVP_CIPHER *cipher)
@@ -90,12 +91,14 @@ EVP_CIPHER_meth_dup(const EVP_CIPHER *cipher)
 
         return copy;
 }
+LCRYPTO_ALIAS(EVP_CIPHER_meth_dup);
 
 void
 EVP_CIPHER_meth_free(EVP_CIPHER *cipher)
 {
         free(cipher);
 }
+LCRYPTO_ALIAS(EVP_CIPHER_meth_free);
 
 int
 EVP_CIPHER_meth_set_iv_length(EVP_CIPHER *cipher, int iv_len)
@@ -104,6 +107,7 @@ EVP_CIPHER_meth_set_iv_length(EVP_CIPHER *cipher, int iv_len)
 
         return 1;
 }
+LCRYPTO_ALIAS(EVP_CIPHER_meth_set_iv_length);
 
 int
 EVP_CIPHER_meth_set_flags(EVP_CIPHER *cipher, unsigned long flags)
@@ -112,6 +116,7 @@ EVP_CIPHER_meth_set_flags(EVP_CIPHER *cipher, unsigned long flags)
 
         return 1;
 }
+LCRYPTO_ALIAS(EVP_CIPHER_meth_set_flags);
 
 int
 EVP_CIPHER_meth_set_impl_ctx_size(EVP_CIPHER *cipher, int ctx_size)
@@ -120,6 +125,7 @@ EVP_CIPHER_meth_set_impl_ctx_size(EVP_CIPHER *cipher, int ctx_size)
 
         return 1;
 }
+LCRYPTO_ALIAS(EVP_CIPHER_meth_set_impl_ctx_size);
 
 int
 EVP_CIPHER_meth_set_init(EVP_CIPHER *cipher,
@@ -130,6 +136,7 @@ EVP_CIPHER_meth_set_init(EVP_CIPHER *cipher,
 
         return 1;
 }
+LCRYPTO_ALIAS(EVP_CIPHER_meth_set_init);
 
 int
 EVP_CIPHER_meth_set_do_cipher(EVP_CIPHER *cipher,
@@ -140,6 +147,7 @@ EVP_CIPHER_meth_set_do_cipher(EVP_CIPHER *cipher,
 
         return 1;
 }
+LCRYPTO_ALIAS(EVP_CIPHER_meth_set_do_cipher);
 
 int
 EVP_CIPHER_meth_set_cleanup(EVP_CIPHER *cipher,
@@ -149,6 +157,7 @@ EVP_CIPHER_meth_set_cleanup(EVP_CIPHER *cipher,
 
         return 1;
 }
+LCRYPTO_ALIAS(EVP_CIPHER_meth_set_cleanup);
 
 int
 EVP_CIPHER_meth_set_set_asn1_params(EVP_CIPHER *cipher,
@@ -158,6 +167,7 @@ EVP_CIPHER_meth_set_set_asn1_params(EVP_CIPHER *cipher,
 
         return 1;
 }
+LCRYPTO_ALIAS(EVP_CIPHER_meth_set_set_asn1_params);
 
 int
 EVP_CIPHER_meth_set_get_asn1_params(EVP_CIPHER *cipher,
@@ -167,6 +177,7 @@ EVP_CIPHER_meth_set_get_asn1_params(EVP_CIPHER *cipher,
 
         return 1;
 }
+LCRYPTO_ALIAS(EVP_CIPHER_meth_set_get_asn1_params);
 
 int
 EVP_CIPHER_meth_set_ctrl(EVP_CIPHER *cipher,
@@ -176,3 +187,4 @@ EVP_CIPHER_meth_set_ctrl(EVP_CIPHER *cipher,
 
         return 1;
 }
+LCRYPTO_ALIAS(EVP_CIPHER_meth_set_ctrl);
diff --git a/src/lib/libcrypto/evp/digest.c b/src/lib/libcrypto/evp/digest.c
index 7c129f025d..6615aa4a35 100644
--- a/src/lib/libcrypto/evp/digest.c
+++ b/src/lib/libcrypto/evp/digest.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: digest.c,v 1.36 2022/12/26 07:18:52 jmc Exp $ */
+/* $OpenBSD: digest.c,v 1.37 2023/07/07 13:54:45 beck Exp $ */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
  * All rights reserved.
  *
@@ -130,6 +130,7 @@ EVP_DigestInit(EVP_MD_CTX *ctx, const EVP_MD *type)
         EVP_MD_CTX_init(ctx);
         return EVP_DigestInit_ex(ctx, type, NULL);
 }
+LCRYPTO_ALIAS(EVP_DigestInit);
 
 int
 EVP_DigestInit_ex(EVP_MD_CTX *ctx, const EVP_MD *type, ENGINE *impl)
@@ -211,12 +212,14 @@ skip_to_init:
                 return 1;
         return ctx->digest->init(ctx);
 }
+LCRYPTO_ALIAS(EVP_DigestInit_ex);
 
 int
 EVP_DigestUpdate(EVP_MD_CTX *ctx, const void *data, size_t count)
 {
         return ctx->update(ctx, data, count);
 }
+LCRYPTO_ALIAS(EVP_DigestUpdate);
 
 /* The caller can assume that this removes any secret data from the context */
 int
@@ -228,6 +231,7 @@ EVP_DigestFinal(EVP_MD_CTX *ctx, unsigned char *md, unsigned int *size)
         EVP_MD_CTX_cleanup(ctx);
         return ret;
 }
+LCRYPTO_ALIAS(EVP_DigestFinal);
 
 /* The caller can assume that this removes any secret data from the context */
 int
@@ -249,6 +253,7 @@ EVP_DigestFinal_ex(EVP_MD_CTX *ctx, unsigned char *md, unsigned int *size)
         memset(ctx->md_data, 0, ctx->digest->ctx_size);
         return ret;
 }
+LCRYPTO_ALIAS(EVP_DigestFinal_ex);
 
 int
 EVP_MD_CTX_copy(EVP_MD_CTX *out, const EVP_MD_CTX *in)
@@ -256,6 +261,7 @@ EVP_MD_CTX_copy(EVP_MD_CTX *out, const EVP_MD_CTX *in)
         EVP_MD_CTX_init(out);
         return EVP_MD_CTX_copy_ex(out, in);
 }
+LCRYPTO_ALIAS(EVP_MD_CTX_copy);
 
 int
 EVP_MD_CTX_copy_ex(EVP_MD_CTX *out, const EVP_MD_CTX *in)
@@ -318,6 +324,7 @@ EVP_MD_CTX_copy_ex(EVP_MD_CTX *out, const EVP_MD_CTX *in)
 
         return 1;
 }
+LCRYPTO_ALIAS(EVP_MD_CTX_copy_ex);
 
 int
 EVP_Digest(const void *data, size_t count,
@@ -335,12 +342,14 @@ EVP_Digest(const void *data, size_t count,
 
         return ret;
 }
+LCRYPTO_ALIAS(EVP_Digest);
 
 EVP_MD_CTX *
 EVP_MD_CTX_new(void)
 {
         return calloc(1, sizeof(EVP_MD_CTX));
 }
+LCRYPTO_ALIAS(EVP_MD_CTX_new);
 
 void
 EVP_MD_CTX_free(EVP_MD_CTX *ctx)
@@ -352,30 +361,35 @@ EVP_MD_CTX_free(EVP_MD_CTX *ctx)
 
         free(ctx);
 }
+LCRYPTO_ALIAS(EVP_MD_CTX_free);
 
 void
 EVP_MD_CTX_init(EVP_MD_CTX *ctx)
 {
         memset(ctx, 0, sizeof(*ctx));
 }
+LCRYPTO_ALIAS(EVP_MD_CTX_init);
 
 int
 EVP_MD_CTX_reset(EVP_MD_CTX *ctx)
 {
         return EVP_MD_CTX_cleanup(ctx);
 }
+LCRYPTO_ALIAS(EVP_MD_CTX_reset);
 
 EVP_MD_CTX *
 EVP_MD_CTX_create(void)
 {
         return EVP_MD_CTX_new();
 }
+LCRYPTO_ALIAS(EVP_MD_CTX_create);
 
 void
 EVP_MD_CTX_destroy(EVP_MD_CTX *ctx)
 {
         EVP_MD_CTX_free(ctx);
 }
+LCRYPTO_ALIAS(EVP_MD_CTX_destroy);
 
 /* This call frees resources associated with the context */
 int
@@ -404,6 +418,7 @@ EVP_MD_CTX_cleanup(EVP_MD_CTX *ctx)
 
         return 1;
 }
+LCRYPTO_ALIAS(EVP_MD_CTX_cleanup);
 
 int
 EVP_MD_CTX_ctrl(EVP_MD_CTX *ctx, int type, int arg, void *ptr)
@@ -427,3 +442,4 @@ EVP_MD_CTX_ctrl(EVP_MD_CTX *ctx, int type, int arg, void *ptr)
         }
         return ret;
 }
+LCRYPTO_ALIAS(EVP_MD_CTX_ctrl);
diff --git a/src/lib/libcrypto/evp/e_aes.c b/src/lib/libcrypto/evp/e_aes.c
index 790b26384d..35c8d944ed 100644
--- a/src/lib/libcrypto/evp/e_aes.c
+++ b/src/lib/libcrypto/evp/e_aes.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: e_aes.c,v 1.51 2023/03/01 11:16:06 tb Exp $ */
+/* $OpenBSD: e_aes.c,v 1.52 2023/07/07 13:54:45 beck Exp $ */
 /* ====================================================================
  * Copyright (c) 2001-2011 The OpenSSL Project.  All rights reserved.
  *
@@ -572,6 +572,7 @@ EVP_aes_128_cbc(void)
         return &aes_128_cbc;
 #endif
 }
+LCRYPTO_ALIAS(EVP_aes_128_cbc);
 
 #ifdef AESNI_CAPABLE
 static const EVP_CIPHER aesni_128_ecb = {
@@ -606,6 +607,7 @@ EVP_aes_128_ecb(void)
         return &aes_128_ecb;
 #endif
 }
+LCRYPTO_ALIAS(EVP_aes_128_ecb);
 
 #ifdef AESNI_CAPABLE
 static const EVP_CIPHER aesni_128_ofb = {
@@ -640,6 +642,7 @@ EVP_aes_128_ofb(void)
         return &aes_128_ofb;
 #endif
 }
+LCRYPTO_ALIAS(EVP_aes_128_ofb);
 
 #ifdef AESNI_CAPABLE
 static const EVP_CIPHER aesni_128_cfb = {
@@ -708,6 +711,7 @@ EVP_aes_128_cfb1(void)
         return &aes_128_cfb1;
 #endif
 }
+LCRYPTO_ALIAS(EVP_aes_128_cfb1);
 
 #ifdef AESNI_CAPABLE
 static const EVP_CIPHER aesni_128_cfb8 = {
@@ -742,6 +746,7 @@ EVP_aes_128_cfb8(void)
         return &aes_128_cfb8;
 #endif
 }
+LCRYPTO_ALIAS(EVP_aes_128_cfb8);
 
 #ifdef AESNI_CAPABLE
 static const EVP_CIPHER aesni_128_ctr = {
@@ -776,6 +781,7 @@ EVP_aes_128_ctr(void)
         return &aes_128_ctr;
 #endif
 }
+LCRYPTO_ALIAS(EVP_aes_128_ctr);
 
 
 #ifdef AESNI_CAPABLE
@@ -811,6 +817,7 @@ EVP_aes_192_cbc(void)
         return &aes_192_cbc;
 #endif
 }
+LCRYPTO_ALIAS(EVP_aes_192_cbc);
 
 #ifdef AESNI_CAPABLE
 static const EVP_CIPHER aesni_192_ecb = {
@@ -845,6 +852,7 @@ EVP_aes_192_ecb(void)
         return &aes_192_ecb;
 #endif
 }
+LCRYPTO_ALIAS(EVP_aes_192_ecb);
 
 #ifdef AESNI_CAPABLE
 static const EVP_CIPHER aesni_192_ofb = {
@@ -879,6 +887,7 @@ EVP_aes_192_ofb(void)
         return &aes_192_ofb;
 #endif
 }
+LCRYPTO_ALIAS(EVP_aes_192_ofb);
 
 #ifdef AESNI_CAPABLE
 static const EVP_CIPHER aesni_192_cfb = {
@@ -947,6 +956,7 @@ EVP_aes_192_cfb1(void)
         return &aes_192_cfb1;
 #endif
 }
+LCRYPTO_ALIAS(EVP_aes_192_cfb1);
 
 #ifdef AESNI_CAPABLE
 static const EVP_CIPHER aesni_192_cfb8 = {
@@ -981,6 +991,7 @@ EVP_aes_192_cfb8(void)
         return &aes_192_cfb8;
 #endif
 }
+LCRYPTO_ALIAS(EVP_aes_192_cfb8);
 
 #ifdef AESNI_CAPABLE
 static const EVP_CIPHER aesni_192_ctr = {
@@ -1015,6 +1026,7 @@ EVP_aes_192_ctr(void)
         return &aes_192_ctr;
 #endif
 }
+LCRYPTO_ALIAS(EVP_aes_192_ctr);
 
 
 #ifdef AESNI_CAPABLE
@@ -1050,6 +1062,7 @@ EVP_aes_256_cbc(void)
         return &aes_256_cbc;
 #endif
 }
+LCRYPTO_ALIAS(EVP_aes_256_cbc);
 
 #ifdef AESNI_CAPABLE
 static const EVP_CIPHER aesni_256_ecb = {
@@ -1084,6 +1097,7 @@ EVP_aes_256_ecb(void)
         return &aes_256_ecb;
 #endif
 }
+LCRYPTO_ALIAS(EVP_aes_256_ecb);
 
 #ifdef AESNI_CAPABLE
 static const EVP_CIPHER aesni_256_ofb = {
@@ -1118,6 +1132,7 @@ EVP_aes_256_ofb(void)
         return &aes_256_ofb;
 #endif
 }
+LCRYPTO_ALIAS(EVP_aes_256_ofb);
 
 #ifdef AESNI_CAPABLE
 static const EVP_CIPHER aesni_256_cfb = {
@@ -1186,6 +1201,7 @@ EVP_aes_256_cfb1(void)
         return &aes_256_cfb1;
 #endif
 }
+LCRYPTO_ALIAS(EVP_aes_256_cfb1);
 
 #ifdef AESNI_CAPABLE
 static const EVP_CIPHER aesni_256_cfb8 = {
@@ -1220,6 +1236,7 @@ EVP_aes_256_cfb8(void)
         return &aes_256_cfb8;
 #endif
 }
+LCRYPTO_ALIAS(EVP_aes_256_cfb8);
 
 #ifdef AESNI_CAPABLE
 static const EVP_CIPHER aesni_256_ctr = {
@@ -1254,6 +1271,7 @@ EVP_aes_256_ctr(void)
         return &aes_256_ctr;
 #endif
 }
+LCRYPTO_ALIAS(EVP_aes_256_ctr);
 
 static int
 aes_gcm_cleanup(EVP_CIPHER_CTX *c)
@@ -1672,6 +1690,7 @@ EVP_aes_128_gcm(void)
         return &aes_128_gcm;
 #endif
 }
+LCRYPTO_ALIAS(EVP_aes_128_gcm);
 
 #ifdef AESNI_CAPABLE
 static const EVP_CIPHER aesni_192_gcm = {
@@ -1710,6 +1729,7 @@ EVP_aes_192_gcm(void)
         return &aes_192_gcm;
 #endif
 }
+LCRYPTO_ALIAS(EVP_aes_192_gcm);
 
 #ifdef AESNI_CAPABLE
 static const EVP_CIPHER aesni_256_gcm = {
@@ -1748,6 +1768,7 @@ EVP_aes_256_gcm(void)
         return &aes_256_gcm;
 #endif
 }
+LCRYPTO_ALIAS(EVP_aes_256_gcm);
 
 static int
 aes_xts_ctrl(EVP_CIPHER_CTX *c, int type, int arg, void *ptr)
@@ -1914,6 +1935,7 @@ EVP_aes_128_xts(void)
         return &aes_128_xts;
 #endif
 }
+LCRYPTO_ALIAS(EVP_aes_128_xts);
 
 #ifdef AESNI_CAPABLE
 static const EVP_CIPHER aesni_256_xts = {
@@ -1952,6 +1974,7 @@ EVP_aes_256_xts(void)
         return &aes_256_xts;
 #endif
 }
+LCRYPTO_ALIAS(EVP_aes_256_xts);
 
 static int
 aes_ccm_ctrl(EVP_CIPHER_CTX *c, int type, int arg, void *ptr)
@@ -2148,6 +2171,7 @@ EVP_aes_128_ccm(void)
         return &aes_128_ccm;
 #endif
 }
+LCRYPTO_ALIAS(EVP_aes_128_ccm);
 
 #ifdef AESNI_CAPABLE
 static const EVP_CIPHER aesni_192_ccm = {
@@ -2186,6 +2210,7 @@ EVP_aes_192_ccm(void)
         return &aes_192_ccm;
 #endif
 }
+LCRYPTO_ALIAS(EVP_aes_192_ccm);
 
 #ifdef AESNI_CAPABLE
 static const EVP_CIPHER aesni_256_ccm = {
@@ -2224,6 +2249,7 @@ EVP_aes_256_ccm(void)
         return &aes_256_ccm;
 #endif
 }
+LCRYPTO_ALIAS(EVP_aes_256_ccm);
 
 #define EVP_AEAD_AES_GCM_TAG_LEN 16
 
@@ -2414,12 +2440,14 @@ EVP_aead_aes_128_gcm(void)
 {
         return &aead_aes_128_gcm;
 }
+LCRYPTO_ALIAS(EVP_aead_aes_128_gcm);
 
 const EVP_AEAD *
 EVP_aead_aes_256_gcm(void)
 {
         return &aead_aes_256_gcm;
 }
+LCRYPTO_ALIAS(EVP_aead_aes_256_gcm);
 
 typedef struct {
         union {
@@ -2545,6 +2573,7 @@ EVP_aes_128_wrap(void)
 {
         return &aes_128_wrap;
 }
+LCRYPTO_ALIAS(EVP_aes_128_wrap);
 
 static const EVP_CIPHER aes_192_wrap = {
         .nid = NID_id_aes192_wrap,
@@ -2567,6 +2596,7 @@ EVP_aes_192_wrap(void)
 {
         return &aes_192_wrap;
 }
+LCRYPTO_ALIAS(EVP_aes_192_wrap);
 
 static const EVP_CIPHER aes_256_wrap = {
         .nid = NID_id_aes256_wrap,
@@ -2589,5 +2619,6 @@ EVP_aes_256_wrap(void)
 {
         return &aes_256_wrap;
 }
+LCRYPTO_ALIAS(EVP_aes_256_wrap);
 
 #endif
diff --git a/src/lib/libcrypto/evp/e_aes_cbc_hmac_sha1.c b/src/lib/libcrypto/evp/e_aes_cbc_hmac_sha1.c
index 9cde386150..b905b359c9 100644
--- a/src/lib/libcrypto/evp/e_aes_cbc_hmac_sha1.c
+++ b/src/lib/libcrypto/evp/e_aes_cbc_hmac_sha1.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: e_aes_cbc_hmac_sha1.c,v 1.17 2022/11/26 16:08:52 tb Exp $ */
+/* $OpenBSD: e_aes_cbc_hmac_sha1.c,v 1.18 2023/07/07 13:54:45 beck Exp $ */
 /* ====================================================================
  * Copyright (c) 2011-2013 The OpenSSL Project.  All rights reserved.
  *
@@ -581,6 +581,7 @@ EVP_aes_128_cbc_hmac_sha1(void)
         return (OPENSSL_cpu_caps() & CPUCAP_MASK_AESNI) ?
             &aesni_128_cbc_hmac_sha1_cipher : NULL;
 }
+LCRYPTO_ALIAS(EVP_aes_128_cbc_hmac_sha1);
 
 const EVP_CIPHER *
 EVP_aes_256_cbc_hmac_sha1(void)
@@ -588,17 +589,20 @@ EVP_aes_256_cbc_hmac_sha1(void)
         return (OPENSSL_cpu_caps() & CPUCAP_MASK_AESNI) ?
             &aesni_256_cbc_hmac_sha1_cipher : NULL;
 }
+LCRYPTO_ALIAS(EVP_aes_256_cbc_hmac_sha1);
 #else
 const EVP_CIPHER *
 EVP_aes_128_cbc_hmac_sha1(void)
 {
         return NULL;
 }
+LCRYPTO_ALIAS(EVP_aes_128_cbc_hmac_sha1);
 
 const EVP_CIPHER *
 EVP_aes_256_cbc_hmac_sha1(void)
 {
             return NULL;
 }
+LCRYPTO_ALIAS(EVP_aes_256_cbc_hmac_sha1);
 #endif
 #endif
diff --git a/src/lib/libcrypto/evp/e_bf.c b/src/lib/libcrypto/evp/e_bf.c
index c2ab3178a5..4e671fab3e 100644
--- a/src/lib/libcrypto/evp/e_bf.c
+++ b/src/lib/libcrypto/evp/e_bf.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: e_bf.c,v 1.15 2022/11/26 16:08:52 tb Exp $ */
+/* $OpenBSD: e_bf.c,v 1.16 2023/07/07 13:54:45 beck Exp $ */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
  * All rights reserved.
  *
@@ -178,6 +178,7 @@ EVP_bf_cbc(void)
 {
         return &bf_cbc;
 }
+LCRYPTO_ALIAS(EVP_bf_cbc);
 
 static const EVP_CIPHER bf_cfb64 = {
         .nid = NID_bf_cfb64,
@@ -200,6 +201,7 @@ EVP_bf_cfb64(void)
 {
         return &bf_cfb64;
 }
+LCRYPTO_ALIAS(EVP_bf_cfb64);
 
 static const EVP_CIPHER bf_ofb = {
         .nid = NID_bf_ofb64,
@@ -222,6 +224,7 @@ EVP_bf_ofb(void)
 {
         return &bf_ofb;
 }
+LCRYPTO_ALIAS(EVP_bf_ofb);
 
 static const EVP_CIPHER bf_ecb = {
         .nid = NID_bf_ecb,
@@ -244,4 +247,5 @@ EVP_bf_ecb(void)
 {
         return &bf_ecb;
 }
+LCRYPTO_ALIAS(EVP_bf_ecb);
 #endif
diff --git a/src/lib/libcrypto/evp/e_camellia.c b/src/lib/libcrypto/evp/e_camellia.c
index 884f8cef2a..0ab6e9ca60 100644
--- a/src/lib/libcrypto/evp/e_camellia.c
+++ b/src/lib/libcrypto/evp/e_camellia.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: e_camellia.c,v 1.16 2022/11/26 16:08:52 tb Exp $ */
+/* $OpenBSD: e_camellia.c,v 1.17 2023/07/07 13:54:45 beck Exp $ */
 /* ====================================================================
  * Copyright (c) 2006 The OpenSSL Project.  All rights reserved.
  *
@@ -179,6 +179,7 @@ EVP_camellia_128_cbc(void)
 {
         return &camellia_128_cbc;
 }
+LCRYPTO_ALIAS(EVP_camellia_128_cbc);
 
 static const EVP_CIPHER camellia_128_cfb128 = {
         .nid = NID_camellia_128_cfb128,
@@ -201,6 +202,7 @@ EVP_camellia_128_cfb128(void)
 {
         return &camellia_128_cfb128;
 }
+LCRYPTO_ALIAS(EVP_camellia_128_cfb128);
 
 static const EVP_CIPHER camellia_128_ofb = {
         .nid = NID_camellia_128_ofb128,
@@ -223,6 +225,7 @@ EVP_camellia_128_ofb(void)
 {
         return &camellia_128_ofb;
 }
+LCRYPTO_ALIAS(EVP_camellia_128_ofb);
 
 static const EVP_CIPHER camellia_128_ecb = {
         .nid = NID_camellia_128_ecb,
@@ -245,6 +248,7 @@ EVP_camellia_128_ecb(void)
 {
         return &camellia_128_ecb;
 }
+LCRYPTO_ALIAS(EVP_camellia_128_ecb);
 
 static int
 camellia_192_cbc_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out, const unsigned char *in, size_t inl)
@@ -337,6 +341,7 @@ EVP_camellia_192_cbc(void)
 {
         return &camellia_192_cbc;
 }
+LCRYPTO_ALIAS(EVP_camellia_192_cbc);
 
 static const EVP_CIPHER camellia_192_cfb128 = {
         .nid = NID_camellia_192_cfb128,
@@ -359,6 +364,7 @@ EVP_camellia_192_cfb128(void)
 {
         return &camellia_192_cfb128;
 }
+LCRYPTO_ALIAS(EVP_camellia_192_cfb128);
 
 static const EVP_CIPHER camellia_192_ofb = {
         .nid = NID_camellia_192_ofb128,
@@ -381,6 +387,7 @@ EVP_camellia_192_ofb(void)
 {
         return &camellia_192_ofb;
 }
+LCRYPTO_ALIAS(EVP_camellia_192_ofb);
 
 static const EVP_CIPHER camellia_192_ecb = {
         .nid = NID_camellia_192_ecb,
@@ -403,6 +410,7 @@ EVP_camellia_192_ecb(void)
 {
         return &camellia_192_ecb;
 }
+LCRYPTO_ALIAS(EVP_camellia_192_ecb);
 
 static int
 camellia_256_cbc_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out, const unsigned char *in, size_t inl)
@@ -495,6 +503,7 @@ EVP_camellia_256_cbc(void)
 {
         return &camellia_256_cbc;
 }
+LCRYPTO_ALIAS(EVP_camellia_256_cbc);
 
 static const EVP_CIPHER camellia_256_cfb128 = {
         .nid = NID_camellia_256_cfb128,
@@ -517,6 +526,7 @@ EVP_camellia_256_cfb128(void)
 {
         return &camellia_256_cfb128;
 }
+LCRYPTO_ALIAS(EVP_camellia_256_cfb128);
 
 static const EVP_CIPHER camellia_256_ofb = {
         .nid = NID_camellia_256_ofb128,
@@ -539,6 +549,7 @@ EVP_camellia_256_ofb(void)
 {
         return &camellia_256_ofb;
 }
+LCRYPTO_ALIAS(EVP_camellia_256_ofb);
 
 static const EVP_CIPHER camellia_256_ecb = {
         .nid = NID_camellia_256_ecb,
@@ -561,6 +572,7 @@ EVP_camellia_256_ecb(void)
 {
         return &camellia_256_ecb;
 }
+LCRYPTO_ALIAS(EVP_camellia_256_ecb);
 
 static int
 camellia_128_cfb1_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out, const unsigned char *in, size_t inl)
@@ -605,6 +617,7 @@ EVP_camellia_128_cfb1(void)
 {
         return &camellia_128_cfb1;
 }
+LCRYPTO_ALIAS(EVP_camellia_128_cfb1);
 
 static int
 camellia_192_cfb1_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out, const unsigned char *in, size_t inl)
@@ -649,6 +662,7 @@ EVP_camellia_192_cfb1(void)
 {
         return &camellia_192_cfb1;
 }
+LCRYPTO_ALIAS(EVP_camellia_192_cfb1);
 
 static int
 camellia_256_cfb1_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out, const unsigned char *in, size_t inl)
@@ -693,6 +707,7 @@ EVP_camellia_256_cfb1(void)
 {
         return &camellia_256_cfb1;
 }
+LCRYPTO_ALIAS(EVP_camellia_256_cfb1);
 
 
 static int
@@ -736,6 +751,7 @@ EVP_camellia_128_cfb8(void)
 {
         return &camellia_128_cfb8;
 }
+LCRYPTO_ALIAS(EVP_camellia_128_cfb8);
 
 static int
 camellia_192_cfb8_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out, const unsigned char *in, size_t inl)
@@ -778,6 +794,7 @@ EVP_camellia_192_cfb8(void)
 {
         return &camellia_192_cfb8;
 }
+LCRYPTO_ALIAS(EVP_camellia_192_cfb8);
 
 static int
 camellia_256_cfb8_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out, const unsigned char *in, size_t inl)
@@ -820,4 +837,5 @@ EVP_camellia_256_cfb8(void)
 {
         return &camellia_256_cfb8;
 }
+LCRYPTO_ALIAS(EVP_camellia_256_cfb8);
 #endif
diff --git a/src/lib/libcrypto/evp/e_cast.c b/src/lib/libcrypto/evp/e_cast.c
index 98683e1d01..8f62ba6f29 100644
--- a/src/lib/libcrypto/evp/e_cast.c
+++ b/src/lib/libcrypto/evp/e_cast.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: e_cast.c,v 1.14 2022/11/26 16:08:52 tb Exp $ */
+/* $OpenBSD: e_cast.c,v 1.15 2023/07/07 13:54:45 beck Exp $ */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
  * All rights reserved.
  *
@@ -178,6 +178,7 @@ EVP_cast5_cbc(void)
 {
         return &cast5_cbc;
 }
+LCRYPTO_ALIAS(EVP_cast5_cbc);
 
 static const EVP_CIPHER cast5_cfb64 = {
         .nid = NID_cast5_cfb64,
@@ -200,6 +201,7 @@ EVP_cast5_cfb64(void)
 {
         return &cast5_cfb64;
 }
+LCRYPTO_ALIAS(EVP_cast5_cfb64);
 
 static const EVP_CIPHER cast5_ofb = {
         .nid = NID_cast5_ofb64,
@@ -222,6 +224,7 @@ EVP_cast5_ofb(void)
 {
         return &cast5_ofb;
 }
+LCRYPTO_ALIAS(EVP_cast5_ofb);
 
 static const EVP_CIPHER cast5_ecb = {
         .nid = NID_cast5_ecb,
@@ -244,4 +247,5 @@ EVP_cast5_ecb(void)
 {
         return &cast5_ecb;
 }
+LCRYPTO_ALIAS(EVP_cast5_ecb);
 #endif
diff --git a/src/lib/libcrypto/evp/e_chacha.c b/src/lib/libcrypto/evp/e_chacha.c
index f27ed1d37d..f781d66339 100644
--- a/src/lib/libcrypto/evp/e_chacha.c
+++ b/src/lib/libcrypto/evp/e_chacha.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: e_chacha.c,v 1.10 2022/11/26 16:08:52 tb Exp $ */
+/* $OpenBSD: e_chacha.c,v 1.11 2023/07/07 13:54:45 beck Exp $ */
 /*
  * Copyright (c) 2014 Joel Sing <jsing@openbsd.org>
  *
@@ -74,5 +74,6 @@ EVP_chacha20(void)
 {
         return (&chacha20_cipher);
 }
+LCRYPTO_ALIAS(EVP_chacha20);
 
 #endif
diff --git a/src/lib/libcrypto/evp/e_chacha20poly1305.c b/src/lib/libcrypto/evp/e_chacha20poly1305.c
index 1bd04c1f1f..4b8f47cefc 100644
--- a/src/lib/libcrypto/evp/e_chacha20poly1305.c
+++ b/src/lib/libcrypto/evp/e_chacha20poly1305.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: e_chacha20poly1305.c,v 1.28 2023/03/01 11:16:06 tb Exp $ */
+/* $OpenBSD: e_chacha20poly1305.c,v 1.29 2023/07/07 13:54:45 beck Exp $ */
 
 /*
  * Copyright (c) 2022 Joel Sing <jsing@openbsd.org>
@@ -348,6 +348,7 @@ EVP_aead_chacha20_poly1305()
 {
         return &aead_chacha20_poly1305;
 }
+LCRYPTO_ALIAS(EVP_aead_chacha20_poly1305);
 
 static const EVP_AEAD aead_xchacha20_poly1305 = {
         .key_len = 32,
@@ -366,6 +367,7 @@ EVP_aead_xchacha20_poly1305()
 {
         return &aead_xchacha20_poly1305;
 }
+LCRYPTO_ALIAS(EVP_aead_xchacha20_poly1305);
 
 struct chacha20_poly1305_ctx {
         ChaCha_ctx chacha;
@@ -606,5 +608,6 @@ EVP_chacha20_poly1305(void)
 {
         return &cipher_chacha20_poly1305;
 }
+LCRYPTO_ALIAS(EVP_chacha20_poly1305);
 
 #endif  /* !OPENSSL_NO_CHACHA && !OPENSSL_NO_POLY1305 */
diff --git a/src/lib/libcrypto/evp/e_des.c b/src/lib/libcrypto/evp/e_des.c
index dffabc8125..c87de1a690 100644
--- a/src/lib/libcrypto/evp/e_des.c
+++ b/src/lib/libcrypto/evp/e_des.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: e_des.c,v 1.20 2022/11/26 16:08:52 tb Exp $ */
+/* $OpenBSD: e_des.c,v 1.21 2023/07/07 13:54:45 beck Exp $ */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
  * All rights reserved.
  *
@@ -242,6 +242,7 @@ EVP_des_cbc(void)
 {
         return &des_cbc;
 }
+LCRYPTO_ALIAS(EVP_des_cbc);
 
 static const EVP_CIPHER des_cfb64 = {
         .nid = NID_des_cfb64,
@@ -264,6 +265,7 @@ EVP_des_cfb64(void)
 {
         return &des_cfb64;
 }
+LCRYPTO_ALIAS(EVP_des_cfb64);
 
 static const EVP_CIPHER des_ofb = {
         .nid = NID_des_ofb64,
@@ -286,6 +288,7 @@ EVP_des_ofb(void)
 {
         return &des_ofb;
 }
+LCRYPTO_ALIAS(EVP_des_ofb);
 
 static const EVP_CIPHER des_ecb = {
         .nid = NID_des_ecb,
@@ -308,6 +311,7 @@ EVP_des_ecb(void)
 {
         return &des_ecb;
 }
+LCRYPTO_ALIAS(EVP_des_ecb);
 
 static const EVP_CIPHER des_cfb1 = {
         .nid = NID_des_cfb1,
@@ -330,6 +334,7 @@ EVP_des_cfb1(void)
 {
         return &des_cfb1;
 }
+LCRYPTO_ALIAS(EVP_des_cfb1);
 
 static const EVP_CIPHER des_cfb8 = {
         .nid = NID_des_cfb8,
@@ -352,4 +357,5 @@ EVP_des_cfb8(void)
 {
         return &des_cfb8;
 }
+LCRYPTO_ALIAS(EVP_des_cfb8);
 #endif
diff --git a/src/lib/libcrypto/evp/e_des3.c b/src/lib/libcrypto/evp/e_des3.c
index d6c7537aea..d345c354c0 100644
--- a/src/lib/libcrypto/evp/e_des3.c
+++ b/src/lib/libcrypto/evp/e_des3.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: e_des3.c,v 1.26 2022/11/26 16:08:52 tb Exp $ */
+/* $OpenBSD: e_des3.c,v 1.27 2023/07/07 13:54:45 beck Exp $ */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
  * All rights reserved.
  *
@@ -274,6 +274,7 @@ EVP_des_ede_cbc(void)
 {
         return &des_ede_cbc;
 }
+LCRYPTO_ALIAS(EVP_des_ede_cbc);
 
 static const EVP_CIPHER des_ede_cfb64 = {
         .nid = NID_des_ede_cfb64,
@@ -296,6 +297,7 @@ EVP_des_ede_cfb64(void)
 {
         return &des_ede_cfb64;
 }
+LCRYPTO_ALIAS(EVP_des_ede_cfb64);
 
 static const EVP_CIPHER des_ede_ofb = {
         .nid = NID_des_ede_ofb64,
@@ -318,6 +320,7 @@ EVP_des_ede_ofb(void)
 {
         return &des_ede_ofb;
 }
+LCRYPTO_ALIAS(EVP_des_ede_ofb);
 
 static const EVP_CIPHER des_ede_ecb = {
         .nid = NID_des_ede_ecb,
@@ -340,6 +343,7 @@ EVP_des_ede_ecb(void)
 {
         return &des_ede_ecb;
 }
+LCRYPTO_ALIAS(EVP_des_ede_ecb);
 
 
 #define des_ede3_cfb64_cipher des_ede_cfb64_cipher
@@ -368,6 +372,7 @@ EVP_des_ede3_cbc(void)
 {
         return &des_ede3_cbc;
 }
+LCRYPTO_ALIAS(EVP_des_ede3_cbc);
 
 static const EVP_CIPHER des_ede3_cfb64 = {
         .nid = NID_des_ede3_cfb64,
@@ -390,6 +395,7 @@ EVP_des_ede3_cfb64(void)
 {
         return &des_ede3_cfb64;
 }
+LCRYPTO_ALIAS(EVP_des_ede3_cfb64);
 
 static const EVP_CIPHER des_ede3_ofb = {
         .nid = NID_des_ede3_ofb64,
@@ -412,6 +418,7 @@ EVP_des_ede3_ofb(void)
 {
         return &des_ede3_ofb;
 }
+LCRYPTO_ALIAS(EVP_des_ede3_ofb);
 
 static const EVP_CIPHER des_ede3_ecb = {
         .nid = NID_des_ede3_ecb,
@@ -434,6 +441,7 @@ EVP_des_ede3_ecb(void)
 {
         return &des_ede3_ecb;
 }
+LCRYPTO_ALIAS(EVP_des_ede3_ecb);
 
 
 static const EVP_CIPHER des_ede3_cfb1 = {
@@ -457,6 +465,7 @@ EVP_des_ede3_cfb1(void)
 {
         return &des_ede3_cfb1;
 }
+LCRYPTO_ALIAS(EVP_des_ede3_cfb1);
 
 
 static const EVP_CIPHER des_ede3_cfb8 = {
@@ -480,16 +489,19 @@ EVP_des_ede3_cfb8(void)
 {
         return &des_ede3_cfb8;
 }
+LCRYPTO_ALIAS(EVP_des_ede3_cfb8);
 
 const EVP_CIPHER *
 EVP_des_ede(void)
 {
         return &des_ede_ecb;
 }
+LCRYPTO_ALIAS(EVP_des_ede);
 
 const EVP_CIPHER *
 EVP_des_ede3(void)
 {
         return &des_ede3_ecb;
 }
+LCRYPTO_ALIAS(EVP_des_ede3);
 #endif
diff --git a/src/lib/libcrypto/evp/e_gost2814789.c b/src/lib/libcrypto/evp/e_gost2814789.c
index 6344a11e9b..fdbc662810 100644
--- a/src/lib/libcrypto/evp/e_gost2814789.c
+++ b/src/lib/libcrypto/evp/e_gost2814789.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: e_gost2814789.c,v 1.11 2022/11/26 16:08:52 tb Exp $ */
+/* $OpenBSD: e_gost2814789.c,v 1.12 2023/07/07 13:54:45 beck Exp $ */
 /*
  * Copyright (c) 2014 Dmitry Eremin-Solenikov <dbaryshkov@gmail.com>
  * Copyright (c) 2005-2006 Cryptocom LTD
@@ -268,6 +268,7 @@ EVP_gost2814789_ecb(void)
 {
         return &gost2814789_ecb;
 }
+LCRYPTO_ALIAS(EVP_gost2814789_ecb);
 
 static const EVP_CIPHER gost2814789_cfb64 = {
         .nid = NID_gost89_cfb64,
@@ -290,6 +291,7 @@ EVP_gost2814789_cfb64(void)
 {
         return &gost2814789_cfb64;
 }
+LCRYPTO_ALIAS(EVP_gost2814789_cfb64);
 
 static const EVP_CIPHER gost2814789_cnt = {
         .nid = NID_gost89_cnt,
@@ -312,4 +314,5 @@ EVP_gost2814789_cnt(void)
 {
         return &gost2814789_cnt;
 }
+LCRYPTO_ALIAS(EVP_gost2814789_cnt);
 #endif
diff --git a/src/lib/libcrypto/evp/e_idea.c b/src/lib/libcrypto/evp/e_idea.c
index b8349ee9cb..e330888ba6 100644
--- a/src/lib/libcrypto/evp/e_idea.c
+++ b/src/lib/libcrypto/evp/e_idea.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: e_idea.c,v 1.18 2022/11/26 16:08:52 tb Exp $ */
+/* $OpenBSD: e_idea.c,v 1.19 2023/07/07 13:54:45 beck Exp $ */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
  * All rights reserved.
  *
@@ -197,6 +197,7 @@ EVP_idea_cbc(void)
 {
         return &idea_cbc;
 }
+LCRYPTO_ALIAS(EVP_idea_cbc);
 
 static const EVP_CIPHER idea_cfb64 = {
         .nid = NID_idea_cfb64,
@@ -219,6 +220,7 @@ EVP_idea_cfb64(void)
 {
         return &idea_cfb64;
 }
+LCRYPTO_ALIAS(EVP_idea_cfb64);
 
 static const EVP_CIPHER idea_ofb = {
         .nid = NID_idea_ofb64,
@@ -241,6 +243,7 @@ EVP_idea_ofb(void)
 {
         return &idea_ofb;
 }
+LCRYPTO_ALIAS(EVP_idea_ofb);
 
 static const EVP_CIPHER idea_ecb = {
         .nid = NID_idea_ecb,
@@ -263,4 +266,5 @@ EVP_idea_ecb(void)
 {
         return &idea_ecb;
 }
+LCRYPTO_ALIAS(EVP_idea_ecb);
 #endif
diff --git a/src/lib/libcrypto/evp/e_null.c b/src/lib/libcrypto/evp/e_null.c
index ddd633dc7c..3daadb1479 100644
--- a/src/lib/libcrypto/evp/e_null.c
+++ b/src/lib/libcrypto/evp/e_null.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: e_null.c,v 1.16 2022/11/26 16:08:52 tb Exp $ */
+/* $OpenBSD: e_null.c,v 1.17 2023/07/07 13:54:45 beck Exp $ */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
  * All rights reserved.
  *
@@ -88,6 +88,7 @@ EVP_enc_null(void)
 {
         return (&n_cipher);
 }
+LCRYPTO_ALIAS(EVP_enc_null);
 
 static int
 null_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key,
diff --git a/src/lib/libcrypto/evp/e_rc2.c b/src/lib/libcrypto/evp/e_rc2.c
index 78697d08c6..540c94cdfd 100644
--- a/src/lib/libcrypto/evp/e_rc2.c
+++ b/src/lib/libcrypto/evp/e_rc2.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: e_rc2.c,v 1.20 2022/11/26 16:08:52 tb Exp $ */
+/* $OpenBSD: e_rc2.c,v 1.21 2023/07/07 13:54:45 beck Exp $ */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
  * All rights reserved.
  *
@@ -180,6 +180,7 @@ EVP_rc2_cbc(void)
 {
         return &rc2_cbc;
 }
+LCRYPTO_ALIAS(EVP_rc2_cbc);
 
 static const EVP_CIPHER rc2_cfb64 = {
         .nid = NID_rc2_cfb64,
@@ -202,6 +203,7 @@ EVP_rc2_cfb64(void)
 {
         return &rc2_cfb64;
 }
+LCRYPTO_ALIAS(EVP_rc2_cfb64);
 
 static const EVP_CIPHER rc2_ofb = {
         .nid = NID_rc2_ofb64,
@@ -224,6 +226,7 @@ EVP_rc2_ofb(void)
 {
         return &rc2_ofb;
 }
+LCRYPTO_ALIAS(EVP_rc2_ofb);
 
 static const EVP_CIPHER rc2_ecb = {
         .nid = NID_rc2_ecb,
@@ -246,6 +249,7 @@ EVP_rc2_ecb(void)
 {
         return &rc2_ecb;
 }
+LCRYPTO_ALIAS(EVP_rc2_ecb);
 
 #define RC2_40_MAGIC    0xa0
 #define RC2_64_MAGIC    0x78
@@ -284,12 +288,14 @@ EVP_rc2_64_cbc(void)
 {
         return (&r2_64_cbc_cipher);
 }
+LCRYPTO_ALIAS(EVP_rc2_64_cbc);
 
 const EVP_CIPHER *
 EVP_rc2_40_cbc(void)
 {
         return (&r2_40_cbc_cipher);
 }
+LCRYPTO_ALIAS(EVP_rc2_40_cbc);
 
 static int
 rc2_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key,
diff --git a/src/lib/libcrypto/evp/e_rc4.c b/src/lib/libcrypto/evp/e_rc4.c
index 7afc6af9cd..d79bfa729a 100644
--- a/src/lib/libcrypto/evp/e_rc4.c
+++ b/src/lib/libcrypto/evp/e_rc4.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: e_rc4.c,v 1.15 2022/11/26 16:08:52 tb Exp $ */
+/* $OpenBSD: e_rc4.c,v 1.16 2023/07/07 13:54:45 beck Exp $ */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
  * All rights reserved.
  *
@@ -115,12 +115,14 @@ EVP_rc4(void)
 {
         return (&r4_cipher);
 }
+LCRYPTO_ALIAS(EVP_rc4);
 
 const EVP_CIPHER *
 EVP_rc4_40(void)
 {
         return (&r4_40_cipher);
 }
+LCRYPTO_ALIAS(EVP_rc4_40);
 
 static int
 rc4_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key,
diff --git a/src/lib/libcrypto/evp/e_rc4_hmac_md5.c b/src/lib/libcrypto/evp/e_rc4_hmac_md5.c
index b3be57d5f2..1d0bced2df 100644
--- a/src/lib/libcrypto/evp/e_rc4_hmac_md5.c
+++ b/src/lib/libcrypto/evp/e_rc4_hmac_md5.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: e_rc4_hmac_md5.c,v 1.10 2022/11/26 16:08:52 tb Exp $ */
+/* $OpenBSD: e_rc4_hmac_md5.c,v 1.11 2023/07/07 13:54:45 beck Exp $ */
 /* ====================================================================
  * Copyright (c) 2011 The OpenSSL Project.  All rights reserved.
  *
@@ -304,4 +304,5 @@ EVP_rc4_hmac_md5(void)
 {
         return (&r4_hmac_md5_cipher);
 }
+LCRYPTO_ALIAS(EVP_rc4_hmac_md5);
 #endif
diff --git a/src/lib/libcrypto/evp/e_sm4.c b/src/lib/libcrypto/evp/e_sm4.c
index 0d37448109..705a914821 100644
--- a/src/lib/libcrypto/evp/e_sm4.c
+++ b/src/lib/libcrypto/evp/e_sm4.c
@@ -1,4 +1,4 @@
-/*      $OpenBSD: e_sm4.c,v 1.7 2022/11/26 16:08:52 tb Exp $    */
+/*      $OpenBSD: e_sm4.c,v 1.8 2023/07/07 13:54:45 beck Exp $  */
 /*
  * Copyright (c) 2017, 2019 Ribose Inc
  *
@@ -165,6 +165,7 @@ EVP_sm4_cbc(void)
 {
         return &sm4_cbc;
 }
+LCRYPTO_ALIAS(EVP_sm4_cbc);
 
 static const EVP_CIPHER sm4_cfb128 = {
         .nid = NID_sm4_cfb128,
@@ -187,6 +188,7 @@ EVP_sm4_cfb128(void)
 {
         return &sm4_cfb128;
 }
+LCRYPTO_ALIAS(EVP_sm4_cfb128);
 
 static const EVP_CIPHER sm4_ofb = {
         .nid = NID_sm4_ofb128,
@@ -209,6 +211,7 @@ EVP_sm4_ofb(void)
 {
         return &sm4_ofb;
 }
+LCRYPTO_ALIAS(EVP_sm4_ofb);
 
 static const EVP_CIPHER sm4_ecb = {
         .nid = NID_sm4_ecb,
@@ -231,6 +234,7 @@ EVP_sm4_ecb(void)
 {
         return &sm4_ecb;
 }
+LCRYPTO_ALIAS(EVP_sm4_ecb);
 
 static int
 sm4_ctr_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out, const unsigned char *in,
@@ -264,4 +268,5 @@ EVP_sm4_ctr(void)
 {
         return &sm4_ctr_mode;
 }
+LCRYPTO_ALIAS(EVP_sm4_ctr);
 #endif
diff --git a/src/lib/libcrypto/evp/e_xcbc_d.c b/src/lib/libcrypto/evp/e_xcbc_d.c
index bbbc3a1ee9..c7810a2c22 100644
--- a/src/lib/libcrypto/evp/e_xcbc_d.c
+++ b/src/lib/libcrypto/evp/e_xcbc_d.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: e_xcbc_d.c,v 1.13 2022/11/26 16:08:52 tb Exp $ */
+/* $OpenBSD: e_xcbc_d.c,v 1.14 2023/07/07 13:54:45 beck Exp $ */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
  * All rights reserved.
  *
@@ -102,6 +102,7 @@ EVP_desx_cbc(void)
 {
         return (&d_xcbc_cipher);
 }
+LCRYPTO_ALIAS(EVP_desx_cbc);
 
 static int
 desx_cbc_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key,
diff --git a/src/lib/libcrypto/evp/encode.c b/src/lib/libcrypto/evp/encode.c
index 718bdb5fc4..10cb51217a 100644
--- a/src/lib/libcrypto/evp/encode.c
+++ b/src/lib/libcrypto/evp/encode.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: encode.c,v 1.30 2022/11/26 16:08:52 tb Exp $ */
+/* $OpenBSD: encode.c,v 1.31 2023/07/07 13:54:45 beck Exp $ */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
  * All rights reserved.
  *
@@ -128,12 +128,14 @@ EVP_ENCODE_CTX_new(void)
 {
         return calloc(1, sizeof(EVP_ENCODE_CTX));
 }
+LCRYPTO_ALIAS(EVP_ENCODE_CTX_new);
 
 void
 EVP_ENCODE_CTX_free(EVP_ENCODE_CTX *ctx)
 {
         free(ctx);
 }
+LCRYPTO_ALIAS(EVP_ENCODE_CTX_free);
 
 void
 EVP_EncodeInit(EVP_ENCODE_CTX *ctx)
@@ -142,6 +144,7 @@ EVP_EncodeInit(EVP_ENCODE_CTX *ctx)
         ctx->num = 0;
         ctx->line_num = 0;
 }
+LCRYPTO_ALIAS(EVP_EncodeInit);
 
 int
 EVP_EncodeUpdate(EVP_ENCODE_CTX *ctx, unsigned char *out, int *outl,
@@ -192,6 +195,7 @@ EVP_EncodeUpdate(EVP_ENCODE_CTX *ctx, unsigned char *out, int *outl,
 
         return 1;
 }
+LCRYPTO_ALIAS(EVP_EncodeUpdate);
 
 void
 EVP_EncodeFinal(EVP_ENCODE_CTX *ctx, unsigned char *out, int *outl)
@@ -206,6 +210,7 @@ EVP_EncodeFinal(EVP_ENCODE_CTX *ctx, unsigned char *out, int *outl)
         }
         *outl = ret;
 }
+LCRYPTO_ALIAS(EVP_EncodeFinal);
 
 int
 EVP_EncodeBlock(unsigned char *t, const unsigned char *f, int dlen)
@@ -238,6 +243,7 @@ EVP_EncodeBlock(unsigned char *t, const unsigned char *f, int dlen)
         *t = '\0';
         return (ret);
 }
+LCRYPTO_ALIAS(EVP_EncodeBlock);
 
 void
 EVP_DecodeInit(EVP_ENCODE_CTX *ctx)
@@ -247,6 +253,7 @@ EVP_DecodeInit(EVP_ENCODE_CTX *ctx)
         ctx->line_num = 0;
         ctx->expect_nl = 0;
 }
+LCRYPTO_ALIAS(EVP_DecodeInit);
 
 int
 EVP_DecodeUpdate(EVP_ENCODE_CTX *ctx, unsigned char *out, int *outl,
@@ -355,6 +362,7 @@ EVP_DecodeUpdate(EVP_ENCODE_CTX *ctx, unsigned char *out, int *outl,
         ctx->num = n;
         return (rv);
 }
+LCRYPTO_ALIAS(EVP_DecodeUpdate);
 
 int
 EVP_DecodeBlock(unsigned char *t, const unsigned char *f, int n)
@@ -395,6 +403,7 @@ EVP_DecodeBlock(unsigned char *t, const unsigned char *f, int n)
         }
         return (ret);
 }
+LCRYPTO_ALIAS(EVP_DecodeBlock);
 
 int
 EVP_DecodeFinal(EVP_ENCODE_CTX *ctx, unsigned char *out, int *outl)
@@ -412,3 +421,4 @@ EVP_DecodeFinal(EVP_ENCODE_CTX *ctx, unsigned char *out, int *outl)
         } else
                 return (1);
 }
+LCRYPTO_ALIAS(EVP_DecodeFinal);
diff --git a/src/lib/libcrypto/evp/evp_aead.c b/src/lib/libcrypto/evp/evp_aead.c
index 58f1c8722d..8b39c7f923 100644
--- a/src/lib/libcrypto/evp/evp_aead.c
+++ b/src/lib/libcrypto/evp/evp_aead.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: evp_aead.c,v 1.8 2022/11/26 16:08:52 tb Exp $ */
+/* $OpenBSD: evp_aead.c,v 1.9 2023/07/07 13:54:45 beck Exp $ */
 /*
  * Copyright (c) 2014, Google Inc.
  *
@@ -28,24 +28,28 @@ EVP_AEAD_key_length(const EVP_AEAD *aead)
 {
         return aead->key_len;
 }
+LCRYPTO_ALIAS(EVP_AEAD_key_length);
 
 size_t
 EVP_AEAD_nonce_length(const EVP_AEAD *aead)
 {
         return aead->nonce_len;
 }
+LCRYPTO_ALIAS(EVP_AEAD_nonce_length);
 
 size_t
 EVP_AEAD_max_overhead(const EVP_AEAD *aead)
 {
         return aead->overhead;
 }
+LCRYPTO_ALIAS(EVP_AEAD_max_overhead);
 
 size_t
 EVP_AEAD_max_tag_len(const EVP_AEAD *aead)
 {
         return aead->max_tag_len;
 }
+LCRYPTO_ALIAS(EVP_AEAD_max_tag_len);
 
 int
 EVP_AEAD_CTX_init(EVP_AEAD_CTX *ctx, const EVP_AEAD *aead,
@@ -58,6 +62,7 @@ EVP_AEAD_CTX_init(EVP_AEAD_CTX *ctx, const EVP_AEAD *aead,
         }
         return aead->init(ctx, key, key_len, tag_len);
 }
+LCRYPTO_ALIAS(EVP_AEAD_CTX_init);
 
 void
 EVP_AEAD_CTX_cleanup(EVP_AEAD_CTX *ctx)
@@ -67,12 +72,14 @@ EVP_AEAD_CTX_cleanup(EVP_AEAD_CTX *ctx)
         ctx->aead->cleanup(ctx);
         ctx->aead = NULL;
 }
+LCRYPTO_ALIAS(EVP_AEAD_CTX_cleanup);
 
 EVP_AEAD_CTX *
 EVP_AEAD_CTX_new(void)
 {
         return calloc(1, sizeof(EVP_AEAD_CTX));
 }
+LCRYPTO_ALIAS(EVP_AEAD_CTX_new);
 
 void
 EVP_AEAD_CTX_free(EVP_AEAD_CTX *ctx)
@@ -83,6 +90,7 @@ EVP_AEAD_CTX_free(EVP_AEAD_CTX *ctx)
         EVP_AEAD_CTX_cleanup(ctx);
         free(ctx);
 }
+LCRYPTO_ALIAS(EVP_AEAD_CTX_free);
 
 /* check_alias returns 0 if out points within the buffer determined by in
  * and in_len and 1 otherwise.
@@ -133,6 +141,7 @@ error:
         *out_len = 0;
         return 0;
 }
+LCRYPTO_ALIAS(EVP_AEAD_CTX_seal);
 
 int
 EVP_AEAD_CTX_open(const EVP_AEAD_CTX *ctx, unsigned char *out, size_t *out_len,
@@ -158,3 +167,4 @@ error:
         *out_len = 0;
         return 0;
 }
+LCRYPTO_ALIAS(EVP_AEAD_CTX_open);
diff --git a/src/lib/libcrypto/evp/evp_enc.c b/src/lib/libcrypto/evp/evp_enc.c
index df818e3a62..f9b8deddf5 100644
--- a/src/lib/libcrypto/evp/evp_enc.c
+++ b/src/lib/libcrypto/evp/evp_enc.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: evp_enc.c,v 1.50 2023/03/01 11:16:06 tb Exp $ */
+/* $OpenBSD: evp_enc.c,v 1.51 2023/07/07 13:54:45 beck Exp $ */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
  * All rights reserved.
  *
@@ -82,6 +82,7 @@ EVP_CipherInit(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher,
                 EVP_CIPHER_CTX_init(ctx);
         return EVP_CipherInit_ex(ctx, cipher, NULL, key, iv, enc);
 }
+LCRYPTO_ALIAS(EVP_CipherInit);
 
 int
 EVP_CipherInit_ex(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher, ENGINE *impl,
@@ -230,6 +231,7 @@ skip_to_init:
         ctx->block_mask = ctx->cipher->block_size - 1;
         return 1;
 }
+LCRYPTO_ALIAS(EVP_CipherInit_ex);
 
 int
 EVP_CipherUpdate(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl,
@@ -240,6 +242,7 @@ EVP_CipherUpdate(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl,
         else
                 return EVP_DecryptUpdate(ctx, out, outl, in, inl);
 }
+LCRYPTO_ALIAS(EVP_CipherUpdate);
 
 int
 EVP_CipherFinal_ex(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl)
@@ -249,6 +252,7 @@ EVP_CipherFinal_ex(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl)
         else
                 return EVP_DecryptFinal_ex(ctx, out, outl);
 }
+LCRYPTO_ALIAS(EVP_CipherFinal_ex);
 
 __warn_references(EVP_CipherFinal,
     "EVP_CipherFinal is often misused, please use EVP_CipherFinal_ex and EVP_CIPHER_CTX_cleanup");
@@ -263,6 +267,7 @@ EVP_CipherFinal(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl)
                 ret = EVP_DecryptFinal_ex(ctx, out, outl);
         return ret;
 }
+LCRYPTO_ALIAS(EVP_CipherFinal);
 
 int
 EVP_EncryptInit(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher,
@@ -270,6 +275,7 @@ EVP_EncryptInit(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher,
 {
         return EVP_CipherInit(ctx, cipher, key, iv, 1);
 }
+LCRYPTO_ALIAS(EVP_EncryptInit);
 
 int
 EVP_EncryptInit_ex(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher, ENGINE *impl,
@@ -277,6 +283,7 @@ EVP_EncryptInit_ex(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher, ENGINE *impl,
 {
         return EVP_CipherInit_ex(ctx, cipher, impl, key, iv, 1);
 }
+LCRYPTO_ALIAS(EVP_EncryptInit_ex);
 
 int
 EVP_DecryptInit(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher,
@@ -284,6 +291,7 @@ EVP_DecryptInit(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher,
 {
         return EVP_CipherInit(ctx, cipher, key, iv, 0);
 }
+LCRYPTO_ALIAS(EVP_DecryptInit);
 
 int
 EVP_DecryptInit_ex(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher, ENGINE *impl,
@@ -291,6 +299,7 @@ EVP_DecryptInit_ex(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher, ENGINE *impl,
 {
         return EVP_CipherInit_ex(ctx, cipher, impl, key, iv, 0);
 }
+LCRYPTO_ALIAS(EVP_DecryptInit_ex);
 
 int
 EVP_EncryptUpdate(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl,
@@ -373,6 +382,7 @@ EVP_EncryptUpdate(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl,
         ctx->buf_len = i;
         return 1;
 }
+LCRYPTO_ALIAS(EVP_EncryptUpdate);
 
 __warn_references(EVP_EncryptFinal,
     "EVP_EncryptFinal is often misused, please use EVP_EncryptFinal_ex and EVP_CIPHER_CTX_cleanup");
@@ -385,6 +395,7 @@ EVP_EncryptFinal(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl)
         ret = EVP_EncryptFinal_ex(ctx, out, outl);
         return ret;
 }
+LCRYPTO_ALIAS(EVP_EncryptFinal);
 
 int
 EVP_EncryptFinal_ex(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl)
@@ -431,6 +442,7 @@ EVP_EncryptFinal_ex(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl)
 
         return ret;
 }
+LCRYPTO_ALIAS(EVP_EncryptFinal_ex);
 
 int
 EVP_DecryptUpdate(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl,
@@ -501,6 +513,7 @@ EVP_DecryptUpdate(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl,
 
         return 1;
 }
+LCRYPTO_ALIAS(EVP_DecryptUpdate);
 
 __warn_references(EVP_DecryptFinal,
     "EVP_DecryptFinal is often misused, please use EVP_DecryptFinal_ex and EVP_CIPHER_CTX_cleanup");
@@ -513,6 +526,7 @@ EVP_DecryptFinal(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl)
         ret = EVP_DecryptFinal_ex(ctx, out, outl);
         return ret;
 }
+LCRYPTO_ALIAS(EVP_DecryptFinal);
 
 int
 EVP_DecryptFinal_ex(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl)
@@ -567,12 +581,14 @@ EVP_DecryptFinal_ex(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl)
                 *outl = 0;
         return (1);
 }
+LCRYPTO_ALIAS(EVP_DecryptFinal_ex);
 
 EVP_CIPHER_CTX *
 EVP_CIPHER_CTX_new(void)
 {
         return calloc(1, sizeof(EVP_CIPHER_CTX));
 }
+LCRYPTO_ALIAS(EVP_CIPHER_CTX_new);
 
 void
 EVP_CIPHER_CTX_free(EVP_CIPHER_CTX *ctx)
@@ -584,18 +600,21 @@ EVP_CIPHER_CTX_free(EVP_CIPHER_CTX *ctx)
 
         free(ctx);
 }
+LCRYPTO_ALIAS(EVP_CIPHER_CTX_free);
 
 void
 EVP_CIPHER_CTX_init(EVP_CIPHER_CTX *ctx)
 {
         memset(ctx, 0, sizeof(EVP_CIPHER_CTX));
 }
+LCRYPTO_ALIAS(EVP_CIPHER_CTX_init);
 
 int
 EVP_CIPHER_CTX_reset(EVP_CIPHER_CTX *a)
 {
         return EVP_CIPHER_CTX_cleanup(a);
 }
+LCRYPTO_ALIAS(EVP_CIPHER_CTX_reset);
 
 int
 EVP_CIPHER_CTX_cleanup(EVP_CIPHER_CTX *c)
@@ -619,6 +638,7 @@ EVP_CIPHER_CTX_cleanup(EVP_CIPHER_CTX *c)
 
         return 1;
 }
+LCRYPTO_ALIAS(EVP_CIPHER_CTX_cleanup);
 
 int
 EVP_CIPHER_CTX_set_key_length(EVP_CIPHER_CTX *c, int keylen)
@@ -635,6 +655,7 @@ EVP_CIPHER_CTX_set_key_length(EVP_CIPHER_CTX *c, int keylen)
         EVPerror(EVP_R_INVALID_KEY_LENGTH);
         return 0;
 }
+LCRYPTO_ALIAS(EVP_CIPHER_CTX_set_key_length);
 
 int
 EVP_CIPHER_CTX_set_padding(EVP_CIPHER_CTX *ctx, int pad)
@@ -645,6 +666,7 @@ EVP_CIPHER_CTX_set_padding(EVP_CIPHER_CTX *ctx, int pad)
                 ctx->flags |= EVP_CIPH_NO_PADDING;
         return 1;
 }
+LCRYPTO_ALIAS(EVP_CIPHER_CTX_set_padding);
 
 int
 EVP_CIPHER_CTX_ctrl(EVP_CIPHER_CTX *ctx, int type, int arg, void *ptr)
@@ -668,6 +690,7 @@ EVP_CIPHER_CTX_ctrl(EVP_CIPHER_CTX *ctx, int type, int arg, void *ptr)
         }
         return ret;
 }
+LCRYPTO_ALIAS(EVP_CIPHER_CTX_ctrl);
 
 int
 EVP_CIPHER_CTX_rand_key(EVP_CIPHER_CTX *ctx, unsigned char *key)
@@ -677,6 +700,7 @@ EVP_CIPHER_CTX_rand_key(EVP_CIPHER_CTX *ctx, unsigned char *key)
         arc4random_buf(key, ctx->key_len);
         return 1;
 }
+LCRYPTO_ALIAS(EVP_CIPHER_CTX_rand_key);
 
 int
 EVP_CIPHER_CTX_copy(EVP_CIPHER_CTX *out, const EVP_CIPHER_CTX *in)
@@ -723,3 +747,4 @@ EVP_CIPHER_CTX_copy(EVP_CIPHER_CTX *out, const EVP_CIPHER_CTX *in)
 
         return 1;
 }
+LCRYPTO_ALIAS(EVP_CIPHER_CTX_copy);
diff --git a/src/lib/libcrypto/evp/evp_err.c b/src/lib/libcrypto/evp/evp_err.c
index 9cf89f47fb..8835215c14 100644
--- a/src/lib/libcrypto/evp/evp_err.c
+++ b/src/lib/libcrypto/evp/evp_err.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: evp_err.c,v 1.30 2022/11/10 15:17:30 jsing Exp $ */
+/* $OpenBSD: evp_err.c,v 1.31 2023/07/07 13:54:45 beck Exp $ */
 /* ====================================================================
  * Copyright (c) 1999-2011 The OpenSSL Project.  All rights reserved.
  *
@@ -164,3 +164,4 @@ ERR_load_EVP_strings(void)
         }
 #endif
 }
+LCRYPTO_ALIAS(ERR_load_EVP_strings);
diff --git a/src/lib/libcrypto/evp/evp_key.c b/src/lib/libcrypto/evp/evp_key.c
index 6fc8588cde..148fd2fe92 100644
--- a/src/lib/libcrypto/evp/evp_key.c
+++ b/src/lib/libcrypto/evp/evp_key.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: evp_key.c,v 1.28 2022/11/26 16:08:52 tb Exp $ */
+/* $OpenBSD: evp_key.c,v 1.29 2023/07/07 13:54:45 beck Exp $ */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
  * All rights reserved.
  *
@@ -79,6 +79,7 @@ EVP_set_pw_prompt(const char *prompt)
                 strlcpy(prompt_string, prompt, sizeof(prompt_string));
         }
 }
+LCRYPTO_ALIAS(EVP_set_pw_prompt);
 
 char *
 EVP_get_pw_prompt(void)
@@ -88,12 +89,14 @@ EVP_get_pw_prompt(void)
         else
                 return (prompt_string);
 }
+LCRYPTO_ALIAS(EVP_get_pw_prompt);
 
 int
 EVP_read_pw_string(char *buf, int len, const char *prompt, int verify)
 {
         return EVP_read_pw_string_min(buf, 0, len, prompt, verify);
 }
+LCRYPTO_ALIAS(EVP_read_pw_string);
 
 int
 EVP_read_pw_string_min(char *buf, int min, int len, const char *prompt,
@@ -125,6 +128,7 @@ EVP_read_pw_string_min(char *buf, int min, int len, const char *prompt,
         explicit_bzero(buff, BUFSIZ);
         return ret;
 }
+LCRYPTO_ALIAS(EVP_read_pw_string_min);
 
 int
 EVP_BytesToKey(const EVP_CIPHER *type, const EVP_MD *md,
@@ -210,3 +214,4 @@ err:
         explicit_bzero(md_buf, sizeof md_buf);
         return rv;
 }
+LCRYPTO_ALIAS(EVP_BytesToKey);
diff --git a/src/lib/libcrypto/evp/evp_lib.c b/src/lib/libcrypto/evp/evp_lib.c
index f64842b86f..d6b929c0e3 100644
--- a/src/lib/libcrypto/evp/evp_lib.c
+++ b/src/lib/libcrypto/evp/evp_lib.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: evp_lib.c,v 1.25 2022/11/26 16:08:52 tb Exp $ */
+/* $OpenBSD: evp_lib.c,v 1.26 2023/07/07 13:54:45 beck Exp $ */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
  * All rights reserved.
  *
@@ -79,6 +79,7 @@ EVP_CIPHER_param_to_asn1(EVP_CIPHER_CTX *c, ASN1_TYPE *type)
                 ret = -1;
         return (ret);
 }
+LCRYPTO_ALIAS(EVP_CIPHER_param_to_asn1);
 
 int
 EVP_CIPHER_asn1_to_param(EVP_CIPHER_CTX *c, ASN1_TYPE *type)
@@ -93,6 +94,7 @@ EVP_CIPHER_asn1_to_param(EVP_CIPHER_CTX *c, ASN1_TYPE *type)
                 ret = -1;
         return (ret);
 }
+LCRYPTO_ALIAS(EVP_CIPHER_asn1_to_param);
 
 int
 EVP_CIPHER_get_asn1_iv(EVP_CIPHER_CTX *c, ASN1_TYPE *type)
@@ -114,6 +116,7 @@ EVP_CIPHER_get_asn1_iv(EVP_CIPHER_CTX *c, ASN1_TYPE *type)
         }
         return (i);
 }
+LCRYPTO_ALIAS(EVP_CIPHER_get_asn1_iv);
 
 int
 EVP_CIPHER_set_asn1_iv(EVP_CIPHER_CTX *c, ASN1_TYPE *type)
@@ -131,6 +134,7 @@ EVP_CIPHER_set_asn1_iv(EVP_CIPHER_CTX *c, ASN1_TYPE *type)
         }
         return (i);
 }
+LCRYPTO_ALIAS(EVP_CIPHER_set_asn1_iv);
 
 /* Convert the various cipher NIDs and dummies to a proper OID NID */
 int
@@ -184,18 +188,21 @@ EVP_CIPHER_type(const EVP_CIPHER *ctx)
                 return nid;
         }
 }
+LCRYPTO_ALIAS(EVP_CIPHER_type);
 
 int
 EVP_CIPHER_block_size(const EVP_CIPHER *e)
 {
         return e->block_size;
 }
+LCRYPTO_ALIAS(EVP_CIPHER_block_size);
 
 int
 EVP_CIPHER_CTX_block_size(const EVP_CIPHER_CTX *ctx)
 {
         return ctx->cipher->block_size;
 }
+LCRYPTO_ALIAS(EVP_CIPHER_CTX_block_size);
 
 int
 EVP_Cipher(EVP_CIPHER_CTX *ctx, unsigned char *out, const unsigned char *in,
@@ -203,48 +210,56 @@ EVP_Cipher(EVP_CIPHER_CTX *ctx, unsigned char *out, const unsigned char *in,
 {
         return ctx->cipher->do_cipher(ctx, out, in, inl);
 }
+LCRYPTO_ALIAS(EVP_Cipher);
 
 const EVP_CIPHER *
 EVP_CIPHER_CTX_cipher(const EVP_CIPHER_CTX *ctx)
 {
         return ctx->cipher;
 }
+LCRYPTO_ALIAS(EVP_CIPHER_CTX_cipher);
 
 int
 EVP_CIPHER_CTX_encrypting(const EVP_CIPHER_CTX *ctx)
 {
         return ctx->encrypt;
 }
+LCRYPTO_ALIAS(EVP_CIPHER_CTX_encrypting);
 
 unsigned long
 EVP_CIPHER_flags(const EVP_CIPHER *cipher)
 {
         return cipher->flags;
 }
+LCRYPTO_ALIAS(EVP_CIPHER_flags);
 
 unsigned long
 EVP_CIPHER_CTX_flags(const EVP_CIPHER_CTX *ctx)
 {
         return ctx->cipher->flags;
 }
+LCRYPTO_ALIAS(EVP_CIPHER_CTX_flags);
 
 void *
 EVP_CIPHER_CTX_get_app_data(const EVP_CIPHER_CTX *ctx)
 {
         return ctx->app_data;
 }
+LCRYPTO_ALIAS(EVP_CIPHER_CTX_get_app_data);
 
 void
 EVP_CIPHER_CTX_set_app_data(EVP_CIPHER_CTX *ctx, void *data)
 {
         ctx->app_data = data;
 }
+LCRYPTO_ALIAS(EVP_CIPHER_CTX_set_app_data);
 
 void *
 EVP_CIPHER_CTX_get_cipher_data(const EVP_CIPHER_CTX *ctx)
 {
         return ctx->cipher_data;
 }
+LCRYPTO_ALIAS(EVP_CIPHER_CTX_get_cipher_data);
 
 void *
 EVP_CIPHER_CTX_set_cipher_data(EVP_CIPHER_CTX *ctx, void *cipher_data)
@@ -256,48 +271,56 @@ EVP_CIPHER_CTX_set_cipher_data(EVP_CIPHER_CTX *ctx, void *cipher_data)
 
         return old_cipher_data;
 }
+LCRYPTO_ALIAS(EVP_CIPHER_CTX_set_cipher_data);
 
 int
 EVP_CIPHER_iv_length(const EVP_CIPHER *cipher)
 {
         return cipher->iv_len;
 }
+LCRYPTO_ALIAS(EVP_CIPHER_iv_length);
 
 int
 EVP_CIPHER_CTX_iv_length(const EVP_CIPHER_CTX *ctx)
 {
         return ctx->cipher->iv_len;
 }
+LCRYPTO_ALIAS(EVP_CIPHER_CTX_iv_length);
 
 unsigned char *
 EVP_CIPHER_CTX_buf_noconst(EVP_CIPHER_CTX *ctx)
 {
         return ctx->buf;
 }
+LCRYPTO_ALIAS(EVP_CIPHER_CTX_buf_noconst);
 
 int
 EVP_CIPHER_key_length(const EVP_CIPHER *cipher)
 {
         return cipher->key_len;
 }
+LCRYPTO_ALIAS(EVP_CIPHER_key_length);
 
 int
 EVP_CIPHER_CTX_key_length(const EVP_CIPHER_CTX *ctx)
 {
         return ctx->key_len;
 }
+LCRYPTO_ALIAS(EVP_CIPHER_CTX_key_length);
 
 int
 EVP_CIPHER_nid(const EVP_CIPHER *cipher)
 {
         return cipher->nid;
 }
+LCRYPTO_ALIAS(EVP_CIPHER_nid);
 
 int
 EVP_CIPHER_CTX_nid(const EVP_CIPHER_CTX *ctx)
 {
         return ctx->cipher->nid;
 }
+LCRYPTO_ALIAS(EVP_CIPHER_CTX_nid);
 
 int
 EVP_CIPHER_CTX_get_iv(const EVP_CIPHER_CTX *ctx, unsigned char *iv, size_t len)
@@ -317,6 +340,7 @@ EVP_CIPHER_CTX_get_iv(const EVP_CIPHER_CTX *ctx, unsigned char *iv, size_t len)
         }
         return 1;
 }
+LCRYPTO_ALIAS(EVP_CIPHER_CTX_get_iv);
 
 int
 EVP_CIPHER_CTX_set_iv(EVP_CIPHER_CTX *ctx, const unsigned char *iv, size_t len)
@@ -336,24 +360,28 @@ EVP_CIPHER_CTX_set_iv(EVP_CIPHER_CTX *ctx, const unsigned char *iv, size_t len)
         }
         return 1;
 }
+LCRYPTO_ALIAS(EVP_CIPHER_CTX_set_iv);
 
 int
 EVP_MD_block_size(const EVP_MD *md)
 {
         return md->block_size;
 }
+LCRYPTO_ALIAS(EVP_MD_block_size);
 
 int
 EVP_MD_type(const EVP_MD *md)
 {
         return md->type;
 }
+LCRYPTO_ALIAS(EVP_MD_type);
 
 int
 EVP_MD_pkey_type(const EVP_MD *md)
 {
         return md->pkey_type;
 }
+LCRYPTO_ALIAS(EVP_MD_pkey_type);
 
 int
 EVP_MD_size(const EVP_MD *md)
@@ -364,12 +392,14 @@ EVP_MD_size(const EVP_MD *md)
         }
         return md->md_size;
 }
+LCRYPTO_ALIAS(EVP_MD_size);
 
 unsigned long
 EVP_MD_flags(const EVP_MD *md)
 {
         return md->flags;
 }
+LCRYPTO_ALIAS(EVP_MD_flags);
 
 EVP_MD *
 EVP_MD_meth_new(int md_type, int pkey_type)
@@ -384,6 +414,7 @@ EVP_MD_meth_new(int md_type, int pkey_type)
 
         return md;
 }
+LCRYPTO_ALIAS(EVP_MD_meth_new);
 
 EVP_MD *
 EVP_MD_meth_dup(const EVP_MD *md)
@@ -397,12 +428,14 @@ EVP_MD_meth_dup(const EVP_MD *md)
 
         return to;
 }
+LCRYPTO_ALIAS(EVP_MD_meth_dup);
 
 void
 EVP_MD_meth_free(EVP_MD *md)
 {
         freezero(md, sizeof(*md));
 }
+LCRYPTO_ALIAS(EVP_MD_meth_free);
 
 int
 EVP_MD_meth_set_input_blocksize(EVP_MD *md, int blocksize)
@@ -410,6 +443,7 @@ EVP_MD_meth_set_input_blocksize(EVP_MD *md, int blocksize)
         md->block_size = blocksize;
         return 1;
 }
+LCRYPTO_ALIAS(EVP_MD_meth_set_input_blocksize);
 
 int
 EVP_MD_meth_set_result_size(EVP_MD *md, int result_size)
@@ -417,6 +451,7 @@ EVP_MD_meth_set_result_size(EVP_MD *md, int result_size)
         md->md_size = result_size;
         return 1;
 }
+LCRYPTO_ALIAS(EVP_MD_meth_set_result_size);
 
 int
 EVP_MD_meth_set_app_datasize(EVP_MD *md, int datasize)
@@ -424,6 +459,7 @@ EVP_MD_meth_set_app_datasize(EVP_MD *md, int datasize)
         md->ctx_size = datasize;
         return 1;
 }
+LCRYPTO_ALIAS(EVP_MD_meth_set_app_datasize);
 
 int
 EVP_MD_meth_set_flags(EVP_MD *md, unsigned long flags)
@@ -431,6 +467,7 @@ EVP_MD_meth_set_flags(EVP_MD *md, unsigned long flags)
         md->flags = flags;
         return 1;
 }
+LCRYPTO_ALIAS(EVP_MD_meth_set_flags);
 
 int
 EVP_MD_meth_set_init(EVP_MD *md, int (*init)(EVP_MD_CTX *ctx))
@@ -438,6 +475,7 @@ EVP_MD_meth_set_init(EVP_MD *md, int (*init)(EVP_MD_CTX *ctx))
         md->init = init;
         return 1;
 }
+LCRYPTO_ALIAS(EVP_MD_meth_set_init);
 
 int
 EVP_MD_meth_set_update(EVP_MD *md,
@@ -446,6 +484,7 @@ EVP_MD_meth_set_update(EVP_MD *md,
         md->update = update;
         return 1;
 }
+LCRYPTO_ALIAS(EVP_MD_meth_set_update);
 
 int
 EVP_MD_meth_set_final(EVP_MD *md,
@@ -454,6 +493,7 @@ EVP_MD_meth_set_final(EVP_MD *md,
         md->final = final;
         return 1;
 }
+LCRYPTO_ALIAS(EVP_MD_meth_set_final);
 
 int
 EVP_MD_meth_set_copy(EVP_MD *md,
@@ -462,6 +502,7 @@ EVP_MD_meth_set_copy(EVP_MD *md,
         md->copy = copy;
         return 1;
 }
+LCRYPTO_ALIAS(EVP_MD_meth_set_copy);
 
 int
 EVP_MD_meth_set_cleanup(EVP_MD *md,
@@ -470,6 +511,7 @@ EVP_MD_meth_set_cleanup(EVP_MD *md,
         md->cleanup = cleanup;
         return 1;
 }
+LCRYPTO_ALIAS(EVP_MD_meth_set_cleanup);
 
 int
 EVP_MD_meth_set_ctrl(EVP_MD *md,
@@ -478,6 +520,7 @@ EVP_MD_meth_set_ctrl(EVP_MD *md,
         md->md_ctrl = ctrl;
         return 1;
 }
+LCRYPTO_ALIAS(EVP_MD_meth_set_ctrl);
 
 const EVP_MD *
 EVP_MD_CTX_md(const EVP_MD_CTX *ctx)
@@ -486,18 +529,21 @@ EVP_MD_CTX_md(const EVP_MD_CTX *ctx)
                 return NULL;
         return ctx->digest;
 }
+LCRYPTO_ALIAS(EVP_MD_CTX_md);
 
 void *
 EVP_MD_CTX_md_data(const EVP_MD_CTX *ctx)
 {
         return ctx->md_data;
 }
+LCRYPTO_ALIAS(EVP_MD_CTX_md_data);
 
 EVP_PKEY_CTX *
 EVP_MD_CTX_pkey_ctx(const EVP_MD_CTX *ctx)
 {
         return ctx->pctx;
 }
+LCRYPTO_ALIAS(EVP_MD_CTX_pkey_ctx);
 
 void
 EVP_MD_CTX_set_pkey_ctx(EVP_MD_CTX *ctx, EVP_PKEY_CTX *pctx)
@@ -521,39 +567,46 @@ EVP_MD_CTX_set_pkey_ctx(EVP_MD_CTX *ctx, EVP_PKEY_CTX *pctx)
                 EVP_MD_CTX_set_flags(ctx, EVP_MD_CTX_FLAG_KEEP_PKEY_CTX);
         }
 }
+LCRYPTO_ALIAS(EVP_MD_CTX_set_pkey_ctx);
 
 void
 EVP_MD_CTX_set_flags(EVP_MD_CTX *ctx, int flags)
 {
         ctx->flags |= flags;
 }
+LCRYPTO_ALIAS(EVP_MD_CTX_set_flags);
 
 void
 EVP_MD_CTX_clear_flags(EVP_MD_CTX *ctx, int flags)
 {
         ctx->flags &= ~flags;
 }
+LCRYPTO_ALIAS(EVP_MD_CTX_clear_flags);
 
 int
 EVP_MD_CTX_test_flags(const EVP_MD_CTX *ctx, int flags)
 {
         return (ctx->flags & flags);
 }
+LCRYPTO_ALIAS(EVP_MD_CTX_test_flags);
 
 void
 EVP_CIPHER_CTX_set_flags(EVP_CIPHER_CTX *ctx, int flags)
 {
         ctx->flags |= flags;
 }
+LCRYPTO_ALIAS(EVP_CIPHER_CTX_set_flags);
 
 void
 EVP_CIPHER_CTX_clear_flags(EVP_CIPHER_CTX *ctx, int flags)
 {
         ctx->flags &= ~flags;
 }
+LCRYPTO_ALIAS(EVP_CIPHER_CTX_clear_flags);
 
 int
 EVP_CIPHER_CTX_test_flags(const EVP_CIPHER_CTX *ctx, int flags)
 {
         return (ctx->flags & flags);
 }
+LCRYPTO_ALIAS(EVP_CIPHER_CTX_test_flags);
diff --git a/src/lib/libcrypto/evp/evp_pbe.c b/src/lib/libcrypto/evp/evp_pbe.c
index 565955524a..5592521e62 100644
--- a/src/lib/libcrypto/evp/evp_pbe.c
+++ b/src/lib/libcrypto/evp/evp_pbe.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: evp_pbe.c,v 1.27 2022/11/26 16:08:52 tb Exp $ */
+/* $OpenBSD: evp_pbe.c,v 1.28 2023/07/07 13:54:45 beck Exp $ */
 /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
  * project 1999.
  */
@@ -170,6 +170,7 @@ EVP_PBE_CipherInit(ASN1_OBJECT *pbe_obj, const char *pass, int passlen,
         }
         return 1;
 }
+LCRYPTO_ALIAS(EVP_PBE_CipherInit);
 
 static int pbe2_cmp_BSEARCH_CMP_FN(const void *, const void *);
 static int pbe2_cmp(EVP_PBE_CTL const *, EVP_PBE_CTL const *);
@@ -246,6 +247,7 @@ EVP_PBE_alg_add_type(int pbe_type, int pbe_nid, int cipher_nid, int md_nid,
         }
         return 1;
 }
+LCRYPTO_ALIAS(EVP_PBE_alg_add_type);
 
 int
 EVP_PBE_alg_add(int nid, const EVP_CIPHER *cipher, const EVP_MD *md,
@@ -265,6 +267,7 @@ EVP_PBE_alg_add(int nid, const EVP_CIPHER *cipher, const EVP_MD *md,
         return EVP_PBE_alg_add_type(EVP_PBE_TYPE_OUTER, nid,
             cipher_nid, md_nid, keygen);
 }
+LCRYPTO_ALIAS(EVP_PBE_alg_add);
 
 int
 EVP_PBE_find(int type, int pbe_nid,
@@ -297,6 +300,7 @@ EVP_PBE_find(int type, int pbe_nid,
                 *pkeygen = pbetmp->keygen;
         return 1;
 }
+LCRYPTO_ALIAS(EVP_PBE_find);
 
 static void
 free_evp_pbe_ctl(EVP_PBE_CTL *pbe)
@@ -310,3 +314,4 @@ EVP_PBE_cleanup(void)
         sk_EVP_PBE_CTL_pop_free(pbe_algs, free_evp_pbe_ctl);
         pbe_algs = NULL;
 }
+LCRYPTO_ALIAS(EVP_PBE_cleanup);
diff --git a/src/lib/libcrypto/evp/evp_pkey.c b/src/lib/libcrypto/evp/evp_pkey.c
index d2fbdee46c..31a59e2536 100644
--- a/src/lib/libcrypto/evp/evp_pkey.c
+++ b/src/lib/libcrypto/evp/evp_pkey.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: evp_pkey.c,v 1.25 2022/11/26 16:08:52 tb Exp $ */
+/* $OpenBSD: evp_pkey.c,v 1.26 2023/07/07 13:54:45 beck Exp $ */
 /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
  * project 1999.
  */
@@ -105,6 +105,7 @@ error:
         EVP_PKEY_free(pkey);
         return NULL;
 }
+LCRYPTO_ALIAS(EVP_PKCS82PKEY);
 
 /* Turn a private key into a PKCS8 structure */
 
@@ -138,6 +139,7 @@ error:
         PKCS8_PRIV_KEY_INFO_free(p8);
         return NULL;
 }
+LCRYPTO_ALIAS(EVP_PKEY2PKCS8);
 
 /* EVP_PKEY attribute functions */
 
@@ -146,12 +148,14 @@ EVP_PKEY_get_attr_count(const EVP_PKEY *key)
 {
         return X509at_get_attr_count(key->attributes);
 }
+LCRYPTO_ALIAS(EVP_PKEY_get_attr_count);
 
 int
 EVP_PKEY_get_attr_by_NID(const EVP_PKEY *key, int nid, int lastpos)
 {
         return X509at_get_attr_by_NID(key->attributes, nid, lastpos);
 }
+LCRYPTO_ALIAS(EVP_PKEY_get_attr_by_NID);
 
 int
 EVP_PKEY_get_attr_by_OBJ(const EVP_PKEY *key, const ASN1_OBJECT *obj,
@@ -159,18 +163,21 @@ EVP_PKEY_get_attr_by_OBJ(const EVP_PKEY *key, const ASN1_OBJECT *obj,
 {
         return X509at_get_attr_by_OBJ(key->attributes, obj, lastpos);
 }
+LCRYPTO_ALIAS(EVP_PKEY_get_attr_by_OBJ);
 
 X509_ATTRIBUTE *
 EVP_PKEY_get_attr(const EVP_PKEY *key, int loc)
 {
         return X509at_get_attr(key->attributes, loc);
 }
+LCRYPTO_ALIAS(EVP_PKEY_get_attr);
 
 X509_ATTRIBUTE *
 EVP_PKEY_delete_attr(EVP_PKEY *key, int loc)
 {
         return X509at_delete_attr(key->attributes, loc);
 }
+LCRYPTO_ALIAS(EVP_PKEY_delete_attr);
 
 int
 EVP_PKEY_add1_attr(EVP_PKEY *key, X509_ATTRIBUTE *attr)
@@ -179,6 +186,7 @@ EVP_PKEY_add1_attr(EVP_PKEY *key, X509_ATTRIBUTE *attr)
                 return 1;
         return 0;
 }
+LCRYPTO_ALIAS(EVP_PKEY_add1_attr);
 
 int
 EVP_PKEY_add1_attr_by_OBJ(EVP_PKEY *key, const ASN1_OBJECT *obj, int type,
@@ -188,6 +196,7 @@ EVP_PKEY_add1_attr_by_OBJ(EVP_PKEY *key, const ASN1_OBJECT *obj, int type,
                 return 1;
         return 0;
 }
+LCRYPTO_ALIAS(EVP_PKEY_add1_attr_by_OBJ);
 
 int
 EVP_PKEY_add1_attr_by_NID(EVP_PKEY *key, int nid, int type,
@@ -197,6 +206,7 @@ EVP_PKEY_add1_attr_by_NID(EVP_PKEY *key, int nid, int type,
                 return 1;
         return 0;
 }
+LCRYPTO_ALIAS(EVP_PKEY_add1_attr_by_NID);
 
 int
 EVP_PKEY_add1_attr_by_txt(EVP_PKEY *key, const char *attrname, int type,
@@ -207,3 +217,4 @@ EVP_PKEY_add1_attr_by_txt(EVP_PKEY *key, const char *attrname, int type,
                 return 1;
         return 0;
 }
+LCRYPTO_ALIAS(EVP_PKEY_add1_attr_by_txt);
diff --git a/src/lib/libcrypto/evp/m_gost2814789.c b/src/lib/libcrypto/evp/m_gost2814789.c
index ca303dab9f..69f927c5a7 100644
--- a/src/lib/libcrypto/evp/m_gost2814789.c
+++ b/src/lib/libcrypto/evp/m_gost2814789.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: m_gost2814789.c,v 1.4 2022/11/26 16:08:52 tb Exp $ */
+/* $OpenBSD: m_gost2814789.c,v 1.5 2023/07/07 13:54:45 beck Exp $ */
 /*
  * Copyright (c) 2014 Dmitry Eremin-Solenikov <dbaryshkov@gmail.com>
  * Copyright (c) 2005-2006 Cryptocom LTD
@@ -110,4 +110,5 @@ EVP_gost2814789imit(void)
 {
         return (&gost2814789imit_md);
 }
+LCRYPTO_ALIAS(EVP_gost2814789imit);
 #endif
diff --git a/src/lib/libcrypto/evp/m_gostr341194.c b/src/lib/libcrypto/evp/m_gostr341194.c
index 33e96a5a2c..e2a65a3147 100644
--- a/src/lib/libcrypto/evp/m_gostr341194.c
+++ b/src/lib/libcrypto/evp/m_gostr341194.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: m_gostr341194.c,v 1.5 2022/11/26 16:08:52 tb Exp $ */
+/* $OpenBSD: m_gostr341194.c,v 1.6 2023/07/07 13:54:45 beck Exp $ */
 /*
  * Copyright (c) 2014 Dmitry Eremin-Solenikov <dbaryshkov@gmail.com>
  * Copyright (c) 2005-2006 Cryptocom LTD
@@ -97,4 +97,5 @@ EVP_gostr341194(void)
 {
         return (&gostr341194_md);
 }
+LCRYPTO_ALIAS(EVP_gostr341194);
 #endif
diff --git a/src/lib/libcrypto/evp/m_md4.c b/src/lib/libcrypto/evp/m_md4.c
index c1e0256b38..d86ed426d3 100644
--- a/src/lib/libcrypto/evp/m_md4.c
+++ b/src/lib/libcrypto/evp/m_md4.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: m_md4.c,v 1.19 2022/11/26 16:08:52 tb Exp $ */
+/* $OpenBSD: m_md4.c,v 1.20 2023/07/07 13:54:45 beck Exp $ */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
  * All rights reserved.
  *
@@ -110,4 +110,5 @@ EVP_md4(void)
 {
         return (&md4_md);
 }
+LCRYPTO_ALIAS(EVP_md4);
 #endif
diff --git a/src/lib/libcrypto/evp/m_md5.c b/src/lib/libcrypto/evp/m_md5.c
index b66b25bab8..18a78016c6 100644
--- a/src/lib/libcrypto/evp/m_md5.c
+++ b/src/lib/libcrypto/evp/m_md5.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: m_md5.c,v 1.18 2022/11/26 16:08:52 tb Exp $ */
+/* $OpenBSD: m_md5.c,v 1.19 2023/07/07 13:54:45 beck Exp $ */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
  * All rights reserved.
  *
@@ -110,4 +110,5 @@ EVP_md5(void)
 {
         return (&md5_md);
 }
+LCRYPTO_ALIAS(EVP_md5);
 #endif
diff --git a/src/lib/libcrypto/evp/m_md5_sha1.c b/src/lib/libcrypto/evp/m_md5_sha1.c
index b1944b881e..32a6f56a1b 100644
--- a/src/lib/libcrypto/evp/m_md5_sha1.c
+++ b/src/lib/libcrypto/evp/m_md5_sha1.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: m_md5_sha1.c,v 1.5 2022/11/26 16:08:52 tb Exp $ */
+/* $OpenBSD: m_md5_sha1.c,v 1.6 2023/07/07 13:54:45 beck Exp $ */
 /*
  * Copyright (c) 2017 Joel Sing <jsing@openbsd.org>
  *
@@ -87,3 +87,4 @@ EVP_md5_sha1(void)
 {
         return &md5_sha1_md;
 }
+LCRYPTO_ALIAS(EVP_md5_sha1);
diff --git a/src/lib/libcrypto/evp/m_null.c b/src/lib/libcrypto/evp/m_null.c
index d09c0007f3..884a47927e 100644
--- a/src/lib/libcrypto/evp/m_null.c
+++ b/src/lib/libcrypto/evp/m_null.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: m_null.c,v 1.12 2022/11/26 16:08:52 tb Exp $ */
+/* $OpenBSD: m_null.c,v 1.13 2023/07/07 13:54:45 beck Exp $ */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
  * All rights reserved.
  *
@@ -101,3 +101,4 @@ EVP_md_null(void)
 {
         return (&null_md);
 }
+LCRYPTO_ALIAS(EVP_md_null);
diff --git a/src/lib/libcrypto/evp/m_ripemd.c b/src/lib/libcrypto/evp/m_ripemd.c
index 896de59d1c..3cba1dcf1b 100644
--- a/src/lib/libcrypto/evp/m_ripemd.c
+++ b/src/lib/libcrypto/evp/m_ripemd.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: m_ripemd.c,v 1.15 2022/11/26 16:08:52 tb Exp $ */
+/* $OpenBSD: m_ripemd.c,v 1.16 2023/07/07 13:54:45 beck Exp $ */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
  * All rights reserved.
  *
@@ -110,4 +110,5 @@ EVP_ripemd160(void)
 {
         return (&ripemd160_md);
 }
+LCRYPTO_ALIAS(EVP_ripemd160);
 #endif
diff --git a/src/lib/libcrypto/evp/m_sha1.c b/src/lib/libcrypto/evp/m_sha1.c
index b7f4705d86..631e19549e 100644
--- a/src/lib/libcrypto/evp/m_sha1.c
+++ b/src/lib/libcrypto/evp/m_sha1.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: m_sha1.c,v 1.23 2023/04/16 16:42:06 jsing Exp $ */
+/* $OpenBSD: m_sha1.c,v 1.24 2023/07/07 13:54:45 beck Exp $ */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
  * All rights reserved.
  *
@@ -110,6 +110,7 @@ EVP_sha1(void)
 {
         return &sha1_md;
 }
+LCRYPTO_ALIAS(EVP_sha1);
 #endif
 
 #ifndef OPENSSL_NO_SHA256
@@ -155,6 +156,7 @@ EVP_sha224(void)
 {
         return &sha224_md;
 }
+LCRYPTO_ALIAS(EVP_sha224);
 
 static int
 sha256_init(EVP_MD_CTX *ctx)
@@ -193,6 +195,7 @@ EVP_sha256(void)
 {
         return &sha256_md;
 }
+LCRYPTO_ALIAS(EVP_sha256);
 #endif  /* ifndef OPENSSL_NO_SHA256 */
 
 #ifndef OPENSSL_NO_SHA512
@@ -234,6 +237,7 @@ EVP_sha384(void)
 {
         return &sha384_md;
 }
+LCRYPTO_ALIAS(EVP_sha384);
 
 static int
 sha512_init(EVP_MD_CTX *ctx)
@@ -272,6 +276,7 @@ EVP_sha512(void)
 {
         return &sha512_md;
 }
+LCRYPTO_ALIAS(EVP_sha512);
 
 static int
 sha512_224_init(EVP_MD_CTX *ctx)
@@ -310,6 +315,7 @@ EVP_sha512_224(void)
 {
         return &sha512_224_md;
 }
+LCRYPTO_ALIAS(EVP_sha512_224);
 
 static int
 sha512_256_init(EVP_MD_CTX *ctx)
@@ -348,4 +354,5 @@ EVP_sha512_256(void)
 {
         return &sha512_256_md;
 }
+LCRYPTO_ALIAS(EVP_sha512_256);
 #endif  /* ifndef OPENSSL_NO_SHA512 */
diff --git a/src/lib/libcrypto/evp/m_sha3.c b/src/lib/libcrypto/evp/m_sha3.c
index 9944ec979d..9137629823 100644
--- a/src/lib/libcrypto/evp/m_sha3.c
+++ b/src/lib/libcrypto/evp/m_sha3.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: m_sha3.c,v 1.1 2023/04/16 17:06:19 jsing Exp $ */
+/* $OpenBSD: m_sha3.c,v 1.2 2023/07/07 13:54:45 beck Exp $ */
 /*
  * Copyright (c) 2023 Joel Sing <jsing@openbsd.org>
  *
@@ -57,6 +57,7 @@ EVP_sha3_224(void)
 {
         return &sha3_224_md;
 }
+LCRYPTO_ALIAS(EVP_sha3_224);
 
 static int
 sha3_256_init(EVP_MD_CTX *ctx)
@@ -95,6 +96,7 @@ EVP_sha3_256(void)
 {
         return &sha3_256_md;
 }
+LCRYPTO_ALIAS(EVP_sha3_256);
 
 static int
 sha3_384_init(EVP_MD_CTX *ctx)
@@ -133,6 +135,7 @@ EVP_sha3_384(void)
 {
         return &sha3_384_md;
 }
+LCRYPTO_ALIAS(EVP_sha3_384);
 
 static int
 sha3_512_init(EVP_MD_CTX *ctx)
@@ -171,3 +174,4 @@ EVP_sha3_512(void)
 {
         return &sha3_512_md;
 }
+LCRYPTO_ALIAS(EVP_sha3_512);
diff --git a/src/lib/libcrypto/evp/m_sigver.c b/src/lib/libcrypto/evp/m_sigver.c
index 49b1ce29b7..950e4a2a2f 100644
--- a/src/lib/libcrypto/evp/m_sigver.c
+++ b/src/lib/libcrypto/evp/m_sigver.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: m_sigver.c,v 1.11 2022/11/26 16:08:52 tb Exp $ */
+/* $OpenBSD: m_sigver.c,v 1.12 2023/07/07 13:54:45 beck Exp $ */
 /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
  * project 2006.
  */
@@ -133,6 +133,7 @@ EVP_DigestSignInit(EVP_MD_CTX *ctx, EVP_PKEY_CTX **pctx, const EVP_MD *type,
 {
         return do_sigver_init(ctx, pctx, type, e, pkey, 0);
 }
+LCRYPTO_ALIAS(EVP_DigestSignInit);
 
 int
 EVP_DigestVerifyInit(EVP_MD_CTX *ctx, EVP_PKEY_CTX **pctx, const EVP_MD *type,
@@ -140,6 +141,7 @@ EVP_DigestVerifyInit(EVP_MD_CTX *ctx, EVP_PKEY_CTX **pctx, const EVP_MD *type,
 {
         return do_sigver_init(ctx, pctx, type, e, pkey, 1);
 }
+LCRYPTO_ALIAS(EVP_DigestVerifyInit);
 
 int
 EVP_DigestSignFinal(EVP_MD_CTX *ctx, unsigned char *sigret, size_t *siglen)
@@ -198,6 +200,7 @@ EVP_DigestSignFinal(EVP_MD_CTX *ctx, unsigned char *sigret, size_t *siglen)
         }
         return 1;
 }
+LCRYPTO_ALIAS(EVP_DigestSignFinal);
 
 int
 EVP_DigestSign(EVP_MD_CTX *ctx, unsigned char *sigret, size_t *siglen,
@@ -214,6 +217,7 @@ EVP_DigestSign(EVP_MD_CTX *ctx, unsigned char *sigret, size_t *siglen,
 
         return EVP_DigestSignFinal(ctx, sigret, siglen);
 }
+LCRYPTO_ALIAS(EVP_DigestSign);
 
 int
 EVP_DigestVerifyFinal(EVP_MD_CTX *ctx, const unsigned char *sig, size_t siglen)
@@ -241,6 +245,7 @@ EVP_DigestVerifyFinal(EVP_MD_CTX *ctx, const unsigned char *sig, size_t siglen)
                 return r;
         return EVP_PKEY_verify(ctx->pctx, sig, siglen, md, mdlen);
 }
+LCRYPTO_ALIAS(EVP_DigestVerifyFinal);
 
 int
 EVP_DigestVerify(EVP_MD_CTX *ctx, const unsigned char *sigret, size_t siglen,
@@ -255,3 +260,4 @@ EVP_DigestVerify(EVP_MD_CTX *ctx, const unsigned char *sigret, size_t siglen,
 
         return EVP_DigestVerifyFinal(ctx, sigret, siglen);
 }
+LCRYPTO_ALIAS(EVP_DigestVerify);
diff --git a/src/lib/libcrypto/evp/m_sm3.c b/src/lib/libcrypto/evp/m_sm3.c
index bf0ef527eb..169a492d68 100644
--- a/src/lib/libcrypto/evp/m_sm3.c
+++ b/src/lib/libcrypto/evp/m_sm3.c
@@ -1,4 +1,4 @@
-/*      $OpenBSD: m_sm3.c,v 1.4 2022/11/26 16:08:52 tb Exp $    */
+/*      $OpenBSD: m_sm3.c,v 1.5 2023/07/07 13:54:46 beck Exp $  */
 /*
  * Copyright (c) 2018, Ribose Inc
  *
@@ -64,5 +64,6 @@ EVP_sm3(void)
 {
         return &sm3_md;
 }
+LCRYPTO_ALIAS(EVP_sm3);
 
 #endif /* OPENSSL_NO_SM3 */
diff --git a/src/lib/libcrypto/evp/m_streebog.c b/src/lib/libcrypto/evp/m_streebog.c
index 5a0dece599..ce41e4ca8f 100644
--- a/src/lib/libcrypto/evp/m_streebog.c
+++ b/src/lib/libcrypto/evp/m_streebog.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: m_streebog.c,v 1.5 2022/11/26 16:08:52 tb Exp $ */
+/* $OpenBSD: m_streebog.c,v 1.6 2023/07/07 13:54:46 beck Exp $ */
 /*
  * Copyright (c) 2014 Dmitry Eremin-Solenikov <dbaryshkov@gmail.com>
  * Copyright (c) 2005-2006 Cryptocom LTD
@@ -124,10 +124,12 @@ EVP_streebog256(void)
 {
         return (&streebog256_md);
 }
+LCRYPTO_ALIAS(EVP_streebog256);
 
 const EVP_MD *
 EVP_streebog512(void)
 {
         return (&streebog512_md);
 }
+LCRYPTO_ALIAS(EVP_streebog512);
 #endif
diff --git a/src/lib/libcrypto/evp/m_wp.c b/src/lib/libcrypto/evp/m_wp.c
index 2e0b46d5d3..9bd43370e6 100644
--- a/src/lib/libcrypto/evp/m_wp.c
+++ b/src/lib/libcrypto/evp/m_wp.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: m_wp.c,v 1.11 2022/11/26 16:08:52 tb Exp $ */
+/* $OpenBSD: m_wp.c,v 1.12 2023/07/07 13:54:46 beck Exp $ */
 
 #include <stdio.h>
 
@@ -50,4 +50,5 @@ EVP_whirlpool(void)
 {
         return (&whirlpool_md);
 }
+LCRYPTO_ALIAS(EVP_whirlpool);
 #endif
diff --git a/src/lib/libcrypto/evp/names.c b/src/lib/libcrypto/evp/names.c
index 10ce13bb89..c6109a5356 100644
--- a/src/lib/libcrypto/evp/names.c
+++ b/src/lib/libcrypto/evp/names.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: names.c,v 1.17 2023/06/29 06:11:33 tb Exp $ */
+/* $OpenBSD: names.c,v 1.18 2023/07/07 13:54:46 beck Exp $ */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
  * All rights reserved.
  *
@@ -84,6 +84,7 @@ EVP_add_cipher(const EVP_CIPHER *c)
             (const char *)c);
         return (r);
 }
+LCRYPTO_ALIAS(EVP_add_cipher);
 
 int
 EVP_add_digest(const EVP_MD *md)
@@ -112,6 +113,7 @@ EVP_add_digest(const EVP_MD *md)
         }
         return (r);
 }
+LCRYPTO_ALIAS(EVP_add_digest);
 
 const EVP_CIPHER *
 EVP_get_cipherbyname(const char *name)
@@ -124,6 +126,7 @@ EVP_get_cipherbyname(const char *name)
         cp = (const EVP_CIPHER *)OBJ_NAME_get(name, OBJ_NAME_TYPE_CIPHER_METH);
         return (cp);
 }
+LCRYPTO_ALIAS(EVP_get_cipherbyname);
 
 const EVP_MD *
 EVP_get_digestbyname(const char *name)
@@ -136,6 +139,7 @@ EVP_get_digestbyname(const char *name)
         cp = (const EVP_MD *)OBJ_NAME_get(name, OBJ_NAME_TYPE_MD_METH);
         return (cp);
 }
+LCRYPTO_ALIAS(EVP_get_digestbyname);
 
 void
 EVP_cleanup(void)
@@ -154,6 +158,7 @@ EVP_cleanup(void)
         }
         OBJ_sigid_free();
 }
+LCRYPTO_ALIAS(EVP_cleanup);
 
 struct doall_cipher {
         void *arg;
@@ -185,6 +190,7 @@ EVP_CIPHER_do_all(void (*fn)(const EVP_CIPHER *ciph, const char *from,
         dc.arg = arg;
         OBJ_NAME_do_all(OBJ_NAME_TYPE_CIPHER_METH, do_all_cipher_fn, &dc);
 }
+LCRYPTO_ALIAS(EVP_CIPHER_do_all);
 
 void
 EVP_CIPHER_do_all_sorted(void (*fn)(const EVP_CIPHER *ciph, const char *from,
@@ -200,6 +206,7 @@ EVP_CIPHER_do_all_sorted(void (*fn)(const EVP_CIPHER *ciph, const char *from,
         OBJ_NAME_do_all_sorted(OBJ_NAME_TYPE_CIPHER_METH,
             do_all_cipher_fn, &dc);
 }
+LCRYPTO_ALIAS(EVP_CIPHER_do_all_sorted);
 
 struct doall_md {
         void *arg;
@@ -231,6 +238,7 @@ EVP_MD_do_all(void (*fn)(const EVP_MD *md, const char *from, const char *to,
         dc.arg = arg;
         OBJ_NAME_do_all(OBJ_NAME_TYPE_MD_METH, do_all_md_fn, &dc);
 }
+LCRYPTO_ALIAS(EVP_MD_do_all);
 
 void
 EVP_MD_do_all_sorted(void (*fn)(const EVP_MD *md,
@@ -245,3 +253,4 @@ EVP_MD_do_all_sorted(void (*fn)(const EVP_MD *md,
         dc.arg = arg;
         OBJ_NAME_do_all_sorted(OBJ_NAME_TYPE_MD_METH, do_all_md_fn, &dc);
 }
+LCRYPTO_ALIAS(EVP_MD_do_all_sorted);
diff --git a/src/lib/libcrypto/evp/p5_crpt.c b/src/lib/libcrypto/evp/p5_crpt.c
index e85a60f50e..cf30ad9176 100644
--- a/src/lib/libcrypto/evp/p5_crpt.c
+++ b/src/lib/libcrypto/evp/p5_crpt.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: p5_crpt.c,v 1.21 2022/11/26 16:08:52 tb Exp $ */
+/* $OpenBSD: p5_crpt.c,v 1.22 2023/07/07 13:54:46 beck Exp $ */
 /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
  * project 1999.
  */
@@ -73,6 +73,7 @@ void
 PKCS5_PBE_add(void)
 {
 }
+LCRYPTO_ALIAS(PKCS5_PBE_add);
 
 int
 PKCS5_PBE_keyivgen(EVP_CIPHER_CTX *cctx, const char *pass, int passlen,
@@ -161,3 +162,4 @@ err:
         PBEPARAM_free(pbe);
         return rv;
 }
+LCRYPTO_ALIAS(PKCS5_PBE_keyivgen);
diff --git a/src/lib/libcrypto/evp/p5_crpt2.c b/src/lib/libcrypto/evp/p5_crpt2.c
index 6c0cf529a4..a6fcc30fa4 100644
--- a/src/lib/libcrypto/evp/p5_crpt2.c
+++ b/src/lib/libcrypto/evp/p5_crpt2.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: p5_crpt2.c,v 1.25 2022/11/26 16:08:52 tb Exp $ */
+/* $OpenBSD: p5_crpt2.c,v 1.26 2023/07/07 13:54:46 beck Exp $ */
 /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
  * project 1999.
  */
@@ -149,6 +149,7 @@ PKCS5_PBKDF2_HMAC(const char *pass, int passlen, const unsigned char *salt,
         HMAC_CTX_cleanup(&hctx_tpl);
         return 1;
 }
+LCRYPTO_ALIAS(PKCS5_PBKDF2_HMAC);
 
 int
 PKCS5_PBKDF2_HMAC_SHA1(const char *pass, int passlen, const unsigned char *salt,
@@ -157,6 +158,7 @@ PKCS5_PBKDF2_HMAC_SHA1(const char *pass, int passlen, const unsigned char *salt,
         return PKCS5_PBKDF2_HMAC(pass, passlen, salt, saltlen, iter,
             EVP_sha1(), keylen, out);
 }
+LCRYPTO_ALIAS(PKCS5_PBKDF2_HMAC_SHA1);
 
 /* Now the key derivation function itself. This is a bit evil because
  * it has to check the ASN1 parameters are valid: and there are quite a
@@ -218,6 +220,7 @@ err:
         PBE2PARAM_free(pbe2);
         return rv;
 }
+LCRYPTO_ALIAS(PKCS5_v2_PBE_keyivgen);
 
 int
 PKCS5_v2_PBKDF2_keyivgen(EVP_CIPHER_CTX *ctx, const char *pass, int passlen,
diff --git a/src/lib/libcrypto/evp/p_dec.c b/src/lib/libcrypto/evp/p_dec.c
index 33dd301911..7225606c31 100644
--- a/src/lib/libcrypto/evp/p_dec.c
+++ b/src/lib/libcrypto/evp/p_dec.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: p_dec.c,v 1.13 2022/11/26 16:08:52 tb Exp $ */
+/* $OpenBSD: p_dec.c,v 1.14 2023/07/07 13:54:46 beck Exp $ */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
  * All rights reserved.
  *
@@ -92,3 +92,4 @@ err:
 #endif
         return (ret);
 }
+LCRYPTO_ALIAS(EVP_PKEY_decrypt_old);
diff --git a/src/lib/libcrypto/evp/p_enc.c b/src/lib/libcrypto/evp/p_enc.c
index 4685f55cad..c2a16234e8 100644
--- a/src/lib/libcrypto/evp/p_enc.c
+++ b/src/lib/libcrypto/evp/p_enc.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: p_enc.c,v 1.13 2022/11/26 16:08:53 tb Exp $ */
+/* $OpenBSD: p_enc.c,v 1.14 2023/07/07 13:54:46 beck Exp $ */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
  * All rights reserved.
  *
@@ -89,3 +89,4 @@ err:
 #endif
         return (ret);
 }
+LCRYPTO_ALIAS(EVP_PKEY_encrypt_old);
diff --git a/src/lib/libcrypto/evp/p_lib.c b/src/lib/libcrypto/evp/p_lib.c
index e1760122c6..325fb605df 100644
--- a/src/lib/libcrypto/evp/p_lib.c
+++ b/src/lib/libcrypto/evp/p_lib.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: p_lib.c,v 1.32 2022/11/26 16:08:53 tb Exp $ */
+/* $OpenBSD: p_lib.c,v 1.33 2023/07/07 13:54:46 beck Exp $ */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
  * All rights reserved.
  *
@@ -93,6 +93,7 @@ EVP_PKEY_bits(const EVP_PKEY *pkey)
                 return pkey->ameth->pkey_bits(pkey);
         return 0;
 }
+LCRYPTO_ALIAS(EVP_PKEY_bits);
 
 int
 EVP_PKEY_security_bits(const EVP_PKEY *pkey)
@@ -104,6 +105,7 @@ EVP_PKEY_security_bits(const EVP_PKEY *pkey)
 
         return pkey->ameth->pkey_security_bits(pkey);
 }
+LCRYPTO_ALIAS(EVP_PKEY_security_bits);
 
 int
 EVP_PKEY_size(const EVP_PKEY *pkey)
@@ -112,6 +114,7 @@ EVP_PKEY_size(const EVP_PKEY *pkey)
                 return pkey->ameth->pkey_size(pkey);
         return 0;
 }
+LCRYPTO_ALIAS(EVP_PKEY_size);
 
 int
 EVP_PKEY_save_parameters(EVP_PKEY *pkey, int mode)
@@ -136,6 +139,7 @@ EVP_PKEY_save_parameters(EVP_PKEY *pkey, int mode)
 #endif
         return (0);
 }
+LCRYPTO_ALIAS(EVP_PKEY_save_parameters);
 
 int
 EVP_PKEY_copy_parameters(EVP_PKEY *to, const EVP_PKEY *from)
@@ -155,6 +159,7 @@ EVP_PKEY_copy_parameters(EVP_PKEY *to, const EVP_PKEY *from)
 err:
         return 0;
 }
+LCRYPTO_ALIAS(EVP_PKEY_copy_parameters);
 
 int
 EVP_PKEY_missing_parameters(const EVP_PKEY *pkey)
@@ -163,6 +168,7 @@ EVP_PKEY_missing_parameters(const EVP_PKEY *pkey)
                 return pkey->ameth->param_missing(pkey);
         return 0;
 }
+LCRYPTO_ALIAS(EVP_PKEY_missing_parameters);
 
 int
 EVP_PKEY_cmp_parameters(const EVP_PKEY *a, const EVP_PKEY *b)
@@ -173,6 +179,7 @@ EVP_PKEY_cmp_parameters(const EVP_PKEY *a, const EVP_PKEY *b)
                 return a->ameth->param_cmp(a, b);
         return -2;
 }
+LCRYPTO_ALIAS(EVP_PKEY_cmp_parameters);
 
 int
 EVP_PKEY_cmp(const EVP_PKEY *a, const EVP_PKEY *b)
@@ -195,6 +202,7 @@ EVP_PKEY_cmp(const EVP_PKEY *a, const EVP_PKEY *b)
 
         return -2;
 }
+LCRYPTO_ALIAS(EVP_PKEY_cmp);
 
 EVP_PKEY *
 EVP_PKEY_new(void)
@@ -216,6 +224,7 @@ EVP_PKEY_new(void)
         ret->save_parameters = 1;
         return (ret);
 }
+LCRYPTO_ALIAS(EVP_PKEY_new);
 
 int
 EVP_PKEY_up_ref(EVP_PKEY *pkey)
@@ -223,6 +232,7 @@ EVP_PKEY_up_ref(EVP_PKEY *pkey)
         int refs = CRYPTO_add(&pkey->references, 1, CRYPTO_LOCK_EVP_PKEY);
         return ((refs > 1) ? 1 : 0);
 }
+LCRYPTO_ALIAS(EVP_PKEY_up_ref);
 
 /* Setup a public key ASN1 method and ENGINE from a NID or a string.
  * If pkey is NULL just return 1 or 0 if the algorithm exists.
@@ -277,6 +287,7 @@ EVP_PKEY_set_type(EVP_PKEY *pkey, int type)
 {
         return pkey_set_type(pkey, NULL, type, NULL, -1);
 }
+LCRYPTO_ALIAS(EVP_PKEY_set_type);
 
 EVP_PKEY *
 EVP_PKEY_new_raw_private_key(int type, ENGINE *engine,
@@ -306,6 +317,7 @@ EVP_PKEY_new_raw_private_key(int type, ENGINE *engine,
 
         return NULL;
 }
+LCRYPTO_ALIAS(EVP_PKEY_new_raw_private_key);
 
 EVP_PKEY *
 EVP_PKEY_new_raw_public_key(int type, ENGINE *engine,
@@ -335,6 +347,7 @@ EVP_PKEY_new_raw_public_key(int type, ENGINE *engine,
 
         return NULL;
 }
+LCRYPTO_ALIAS(EVP_PKEY_new_raw_public_key);
 
 int
 EVP_PKEY_get_raw_private_key(const EVP_PKEY *pkey,
@@ -351,6 +364,7 @@ EVP_PKEY_get_raw_private_key(const EVP_PKEY *pkey,
 
         return 1;
 }
+LCRYPTO_ALIAS(EVP_PKEY_get_raw_private_key);
 
 int
 EVP_PKEY_get_raw_public_key(const EVP_PKEY *pkey,
@@ -367,6 +381,7 @@ EVP_PKEY_get_raw_public_key(const EVP_PKEY *pkey,
 
         return 1;
 }
+LCRYPTO_ALIAS(EVP_PKEY_get_raw_public_key);
 
 EVP_PKEY *
 EVP_PKEY_new_CMAC_key(ENGINE *e, const unsigned char *priv, size_t len,
@@ -397,12 +412,14 @@ EVP_PKEY_new_CMAC_key(ENGINE *e, const unsigned char *priv, size_t len,
         CMAC_CTX_free(cmctx);
         return NULL;
 }
+LCRYPTO_ALIAS(EVP_PKEY_new_CMAC_key);
 
 int
 EVP_PKEY_set_type_str(EVP_PKEY *pkey, const char *str, int len)
 {
         return pkey_set_type(pkey, NULL, EVP_PKEY_NONE, str, len);
 }
+LCRYPTO_ALIAS(EVP_PKEY_set_type_str);
 
 int
 EVP_PKEY_assign(EVP_PKEY *pkey, int type, void *key)
@@ -412,12 +429,14 @@ EVP_PKEY_assign(EVP_PKEY *pkey, int type, void *key)
         pkey->pkey.ptr = key;
         return (key != NULL);
 }
+LCRYPTO_ALIAS(EVP_PKEY_assign);
 
 void *
 EVP_PKEY_get0(const EVP_PKEY *pkey)
 {
         return pkey->pkey.ptr;
 }
+LCRYPTO_ALIAS(EVP_PKEY_get0);
 
 const unsigned char *
 EVP_PKEY_get0_hmac(const EVP_PKEY *pkey, size_t *len)
@@ -434,6 +453,7 @@ EVP_PKEY_get0_hmac(const EVP_PKEY *pkey, size_t *len)
 
         return os->data;
 }
+LCRYPTO_ALIAS(EVP_PKEY_get0_hmac);
 
 #ifndef OPENSSL_NO_RSA
 RSA *
@@ -445,6 +465,7 @@ EVP_PKEY_get0_RSA(EVP_PKEY *pkey)
         }
         return pkey->pkey.rsa;
 }
+LCRYPTO_ALIAS(EVP_PKEY_get0_RSA);
 
 RSA *
 EVP_PKEY_get1_RSA(EVP_PKEY *pkey)
@@ -456,6 +477,7 @@ EVP_PKEY_get1_RSA(EVP_PKEY *pkey)
         RSA_up_ref(pkey->pkey.rsa);
         return pkey->pkey.rsa;
 }
+LCRYPTO_ALIAS(EVP_PKEY_get1_RSA);
 
 int
 EVP_PKEY_set1_RSA(EVP_PKEY *pkey, RSA *key)
@@ -465,6 +487,7 @@ EVP_PKEY_set1_RSA(EVP_PKEY *pkey, RSA *key)
                 RSA_up_ref(key);
         return ret;
 }
+LCRYPTO_ALIAS(EVP_PKEY_set1_RSA);
 #endif
 
 #ifndef OPENSSL_NO_DSA
@@ -477,6 +500,7 @@ EVP_PKEY_get0_DSA(EVP_PKEY *pkey)
         }
         return pkey->pkey.dsa;
 }
+LCRYPTO_ALIAS(EVP_PKEY_get0_DSA);
 
 DSA *
 EVP_PKEY_get1_DSA(EVP_PKEY *pkey)
@@ -488,6 +512,7 @@ EVP_PKEY_get1_DSA(EVP_PKEY *pkey)
         DSA_up_ref(pkey->pkey.dsa);
         return pkey->pkey.dsa;
 }
+LCRYPTO_ALIAS(EVP_PKEY_get1_DSA);
 
 int
 EVP_PKEY_set1_DSA(EVP_PKEY *pkey, DSA *key)
@@ -497,6 +522,7 @@ EVP_PKEY_set1_DSA(EVP_PKEY *pkey, DSA *key)
                 DSA_up_ref(key);
         return ret;
 }
+LCRYPTO_ALIAS(EVP_PKEY_set1_DSA);
 #endif
 
 #ifndef OPENSSL_NO_EC
@@ -509,6 +535,7 @@ EVP_PKEY_get0_EC_KEY(EVP_PKEY *pkey)
         }
         return pkey->pkey.ec;
 }
+LCRYPTO_ALIAS(EVP_PKEY_get0_EC_KEY);
 
 EC_KEY *
 EVP_PKEY_get1_EC_KEY(EVP_PKEY *pkey)
@@ -520,6 +547,7 @@ EVP_PKEY_get1_EC_KEY(EVP_PKEY *pkey)
         EC_KEY_up_ref(pkey->pkey.ec);
         return pkey->pkey.ec;
 }
+LCRYPTO_ALIAS(EVP_PKEY_get1_EC_KEY);
 
 int
 EVP_PKEY_set1_EC_KEY(EVP_PKEY *pkey, EC_KEY *key)
@@ -529,6 +557,7 @@ EVP_PKEY_set1_EC_KEY(EVP_PKEY *pkey, EC_KEY *key)
                 EC_KEY_up_ref(key);
         return ret;
 }
+LCRYPTO_ALIAS(EVP_PKEY_set1_EC_KEY);
 #endif
 
 
@@ -542,6 +571,7 @@ EVP_PKEY_get0_DH(EVP_PKEY *pkey)
         }
         return pkey->pkey.dh;
 }
+LCRYPTO_ALIAS(EVP_PKEY_get0_DH);
 
 DH *
 EVP_PKEY_get1_DH(EVP_PKEY *pkey)
@@ -553,6 +583,7 @@ EVP_PKEY_get1_DH(EVP_PKEY *pkey)
         DH_up_ref(pkey->pkey.dh);
         return pkey->pkey.dh;
 }
+LCRYPTO_ALIAS(EVP_PKEY_get1_DH);
 
 int
 EVP_PKEY_set1_DH(EVP_PKEY *pkey, DH *key)
@@ -562,6 +593,7 @@ EVP_PKEY_set1_DH(EVP_PKEY *pkey, DH *key)
                 DH_up_ref(key);
         return ret;
 }
+LCRYPTO_ALIAS(EVP_PKEY_set1_DH);
 #endif
 
 int
@@ -580,18 +612,21 @@ EVP_PKEY_type(int type)
 #endif
         return ret;
 }
+LCRYPTO_ALIAS(EVP_PKEY_type);
 
 int
 EVP_PKEY_id(const EVP_PKEY *pkey)
 {
         return pkey->type;
 }
+LCRYPTO_ALIAS(EVP_PKEY_id);
 
 int
 EVP_PKEY_base_id(const EVP_PKEY *pkey)
 {
         return EVP_PKEY_type(pkey->type);
 }
+LCRYPTO_ALIAS(EVP_PKEY_base_id);
 
 void
 EVP_PKEY_free(EVP_PKEY *x)
@@ -610,6 +645,7 @@ EVP_PKEY_free(EVP_PKEY *x)
                 sk_X509_ATTRIBUTE_pop_free(x->attributes, X509_ATTRIBUTE_free);
         free(x);
 }
+LCRYPTO_ALIAS(EVP_PKEY_free);
 
 static void
 EVP_PKEY_free_it(EVP_PKEY *x)
@@ -643,6 +679,7 @@ EVP_PKEY_print_public(BIO *out, const EVP_PKEY *pkey, int indent,
 
         return unsup_alg(out, pkey, indent, "Public Key");
 }
+LCRYPTO_ALIAS(EVP_PKEY_print_public);
 
 int
 EVP_PKEY_print_private(BIO *out, const EVP_PKEY *pkey, int indent,
@@ -653,6 +690,7 @@ EVP_PKEY_print_private(BIO *out, const EVP_PKEY *pkey, int indent,
 
         return unsup_alg(out, pkey, indent, "Private Key");
 }
+LCRYPTO_ALIAS(EVP_PKEY_print_private);
 
 int
 EVP_PKEY_print_params(BIO *out, const EVP_PKEY *pkey, int indent,
@@ -662,6 +700,7 @@ EVP_PKEY_print_params(BIO *out, const EVP_PKEY *pkey, int indent,
                 return pkey->ameth->param_print(out, pkey, indent, pctx);
         return unsup_alg(out, pkey, indent, "Parameters");
 }
+LCRYPTO_ALIAS(EVP_PKEY_print_params);
 
 int
 EVP_PKEY_get_default_digest_nid(EVP_PKEY *pkey, int *pnid)
@@ -671,3 +710,4 @@ EVP_PKEY_get_default_digest_nid(EVP_PKEY *pkey, int *pnid)
         return pkey->ameth->pkey_ctrl(pkey, ASN1_PKEY_CTRL_DEFAULT_MD_NID,
             0, pnid);
 }
+LCRYPTO_ALIAS(EVP_PKEY_get_default_digest_nid);
diff --git a/src/lib/libcrypto/evp/p_open.c b/src/lib/libcrypto/evp/p_open.c
index bce900b9ab..5ab36b8ef5 100644
--- a/src/lib/libcrypto/evp/p_open.c
+++ b/src/lib/libcrypto/evp/p_open.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: p_open.c,v 1.21 2022/11/26 16:08:53 tb Exp $ */
+/* $OpenBSD: p_open.c,v 1.22 2023/07/07 13:54:46 beck Exp $ */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
  * All rights reserved.
  *
@@ -114,6 +114,7 @@ err:
         freezero(key, size);
         return (ret);
 }
+LCRYPTO_ALIAS(EVP_OpenInit);
 
 int
 EVP_OpenFinal(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl)
@@ -125,4 +126,5 @@ EVP_OpenFinal(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl)
                 i = EVP_DecryptInit_ex(ctx, NULL, NULL, NULL, NULL);
         return (i);
 }
+LCRYPTO_ALIAS(EVP_OpenFinal);
 #endif
diff --git a/src/lib/libcrypto/evp/p_seal.c b/src/lib/libcrypto/evp/p_seal.c
index 8b9740fbcd..52521e133b 100644
--- a/src/lib/libcrypto/evp/p_seal.c
+++ b/src/lib/libcrypto/evp/p_seal.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: p_seal.c,v 1.14 2014/10/22 13:02:04 jsing Exp $ */
+/* $OpenBSD: p_seal.c,v 1.15 2023/07/07 13:54:46 beck Exp $ */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
  * All rights reserved.
  *
@@ -99,6 +99,7 @@ EVP_SealInit(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *type, unsigned char **ek,
         }
         return (npubk);
 }
+LCRYPTO_ALIAS(EVP_SealInit);
 
 /* MACRO
 void EVP_SealUpdate(ctx,out,outl,in,inl)
@@ -122,3 +123,4 @@ EVP_SealFinal(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl)
                 i = EVP_EncryptInit_ex(ctx, NULL, NULL, NULL, NULL);
         return i;
 }
+LCRYPTO_ALIAS(EVP_SealFinal);
diff --git a/src/lib/libcrypto/evp/p_sign.c b/src/lib/libcrypto/evp/p_sign.c
index 1f78d1efef..13655b076f 100644
--- a/src/lib/libcrypto/evp/p_sign.c
+++ b/src/lib/libcrypto/evp/p_sign.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: p_sign.c,v 1.17 2022/11/26 16:08:53 tb Exp $ */
+/* $OpenBSD: p_sign.c,v 1.18 2023/07/07 13:54:46 beck Exp $ */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
  * All rights reserved.
  *
@@ -102,3 +102,4 @@ EVP_SignFinal(EVP_MD_CTX *ctx, unsigned char *sigret, unsigned int *siglen,
         EVP_PKEY_CTX_free(pkctx);
         return ret;
 }
+LCRYPTO_ALIAS(EVP_SignFinal);
diff --git a/src/lib/libcrypto/evp/p_verify.c b/src/lib/libcrypto/evp/p_verify.c
index 545715325d..601b44e5e0 100644
--- a/src/lib/libcrypto/evp/p_verify.c
+++ b/src/lib/libcrypto/evp/p_verify.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: p_verify.c,v 1.16 2022/11/26 16:08:53 tb Exp $ */
+/* $OpenBSD: p_verify.c,v 1.17 2023/07/07 13:54:46 beck Exp $ */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
  * All rights reserved.
  *
@@ -95,3 +95,4 @@ EVP_VerifyFinal(EVP_MD_CTX *ctx, const unsigned char *sigbuf,
         EVP_PKEY_CTX_free(pkctx);
         return ret;
 }
+LCRYPTO_ALIAS(EVP_VerifyFinal);
diff --git a/src/lib/libcrypto/evp/pmeth_fn.c b/src/lib/libcrypto/evp/pmeth_fn.c
index cab1dfab6f..3025005034 100644
--- a/src/lib/libcrypto/evp/pmeth_fn.c
+++ b/src/lib/libcrypto/evp/pmeth_fn.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: pmeth_fn.c,v 1.7 2022/11/26 16:08:53 tb Exp $ */
+/* $OpenBSD: pmeth_fn.c,v 1.8 2023/07/07 13:54:46 beck Exp $ */
 /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
  * project 2006.
  */
@@ -98,6 +98,7 @@ EVP_PKEY_sign_init(EVP_PKEY_CTX *ctx)
                 ctx->operation = EVP_PKEY_OP_UNDEFINED;
         return ret;
 }
+LCRYPTO_ALIAS(EVP_PKEY_sign_init);
 
 int
 EVP_PKEY_sign(EVP_PKEY_CTX *ctx, unsigned char *sig, size_t *siglen,
@@ -114,6 +115,7 @@ EVP_PKEY_sign(EVP_PKEY_CTX *ctx, unsigned char *sig, size_t *siglen,
         M_check_autoarg(ctx, sig, siglen, EVP_F_EVP_PKEY_SIGN)
         return ctx->pmeth->sign(ctx, sig, siglen, tbs, tbslen);
 }
+LCRYPTO_ALIAS(EVP_PKEY_sign);
 
 int
 EVP_PKEY_verify_init(EVP_PKEY_CTX *ctx)
@@ -132,6 +134,7 @@ EVP_PKEY_verify_init(EVP_PKEY_CTX *ctx)
                 ctx->operation = EVP_PKEY_OP_UNDEFINED;
         return ret;
 }
+LCRYPTO_ALIAS(EVP_PKEY_verify_init);
 
 int
 EVP_PKEY_verify(EVP_PKEY_CTX *ctx, const unsigned char *sig, size_t siglen,
@@ -147,6 +150,7 @@ EVP_PKEY_verify(EVP_PKEY_CTX *ctx, const unsigned char *sig, size_t siglen,
         }
         return ctx->pmeth->verify(ctx, sig, siglen, tbs, tbslen);
 }
+LCRYPTO_ALIAS(EVP_PKEY_verify);
 
 int
 EVP_PKEY_verify_recover_init(EVP_PKEY_CTX *ctx)
@@ -165,6 +169,7 @@ EVP_PKEY_verify_recover_init(EVP_PKEY_CTX *ctx)
                 ctx->operation = EVP_PKEY_OP_UNDEFINED;
         return ret;
 }
+LCRYPTO_ALIAS(EVP_PKEY_verify_recover_init);
 
 int
 EVP_PKEY_verify_recover(EVP_PKEY_CTX *ctx, unsigned char *rout, size_t *routlen,
@@ -181,6 +186,7 @@ EVP_PKEY_verify_recover(EVP_PKEY_CTX *ctx, unsigned char *rout, size_t *routlen,
         M_check_autoarg(ctx, rout, routlen, EVP_F_EVP_PKEY_VERIFY_RECOVER)
         return ctx->pmeth->verify_recover(ctx, rout, routlen, sig, siglen);
 }
+LCRYPTO_ALIAS(EVP_PKEY_verify_recover);
 
 int
 EVP_PKEY_encrypt_init(EVP_PKEY_CTX *ctx)
@@ -199,6 +205,7 @@ EVP_PKEY_encrypt_init(EVP_PKEY_CTX *ctx)
                 ctx->operation = EVP_PKEY_OP_UNDEFINED;
         return ret;
 }
+LCRYPTO_ALIAS(EVP_PKEY_encrypt_init);
 
 int
 EVP_PKEY_encrypt(EVP_PKEY_CTX *ctx, unsigned char *out, size_t *outlen,
@@ -215,6 +222,7 @@ EVP_PKEY_encrypt(EVP_PKEY_CTX *ctx, unsigned char *out, size_t *outlen,
         M_check_autoarg(ctx, out, outlen, EVP_F_EVP_PKEY_ENCRYPT)
         return ctx->pmeth->encrypt(ctx, out, outlen, in, inlen);
 }
+LCRYPTO_ALIAS(EVP_PKEY_encrypt);
 
 int
 EVP_PKEY_decrypt_init(EVP_PKEY_CTX *ctx)
@@ -233,6 +241,7 @@ EVP_PKEY_decrypt_init(EVP_PKEY_CTX *ctx)
                 ctx->operation = EVP_PKEY_OP_UNDEFINED;
         return ret;
 }
+LCRYPTO_ALIAS(EVP_PKEY_decrypt_init);
 
 int
 EVP_PKEY_decrypt(EVP_PKEY_CTX *ctx, unsigned char *out, size_t *outlen,
@@ -249,6 +258,7 @@ EVP_PKEY_decrypt(EVP_PKEY_CTX *ctx, unsigned char *out, size_t *outlen,
         M_check_autoarg(ctx, out, outlen, EVP_F_EVP_PKEY_DECRYPT)
         return ctx->pmeth->decrypt(ctx, out, outlen, in, inlen);
 }
+LCRYPTO_ALIAS(EVP_PKEY_decrypt);
 
 int
 EVP_PKEY_derive_init(EVP_PKEY_CTX *ctx)
@@ -267,6 +277,7 @@ EVP_PKEY_derive_init(EVP_PKEY_CTX *ctx)
                 ctx->operation = EVP_PKEY_OP_UNDEFINED;
         return ret;
 }
+LCRYPTO_ALIAS(EVP_PKEY_derive_init);
 
 int
 EVP_PKEY_derive_set_peer(EVP_PKEY_CTX *ctx, EVP_PKEY *peer)
@@ -328,6 +339,7 @@ EVP_PKEY_derive_set_peer(EVP_PKEY_CTX *ctx, EVP_PKEY *peer)
         CRYPTO_add(&peer->references, 1, CRYPTO_LOCK_EVP_PKEY);
         return 1;
 }
+LCRYPTO_ALIAS(EVP_PKEY_derive_set_peer);
 
 int
 EVP_PKEY_derive(EVP_PKEY_CTX *ctx, unsigned char *key, size_t *pkeylen)
@@ -343,3 +355,4 @@ EVP_PKEY_derive(EVP_PKEY_CTX *ctx, unsigned char *key, size_t *pkeylen)
         M_check_autoarg(ctx, key, pkeylen, EVP_F_EVP_PKEY_DERIVE)
         return ctx->pmeth->derive(ctx, key, pkeylen);
 }
+LCRYPTO_ALIAS(EVP_PKEY_derive);
diff --git a/src/lib/libcrypto/evp/pmeth_gn.c b/src/lib/libcrypto/evp/pmeth_gn.c
index d31bb7c0b4..2b835cd8fe 100644
--- a/src/lib/libcrypto/evp/pmeth_gn.c
+++ b/src/lib/libcrypto/evp/pmeth_gn.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: pmeth_gn.c,v 1.11 2022/11/26 16:08:53 tb Exp $ */
+/* $OpenBSD: pmeth_gn.c,v 1.12 2023/07/07 13:54:46 beck Exp $ */
 /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
  * project 2006.
  */
@@ -85,6 +85,7 @@ EVP_PKEY_paramgen_init(EVP_PKEY_CTX *ctx)
                 ctx->operation = EVP_PKEY_OP_UNDEFINED;
         return ret;
 }
+LCRYPTO_ALIAS(EVP_PKEY_paramgen_init);
 
 int
 EVP_PKEY_paramgen(EVP_PKEY_CTX *ctx, EVP_PKEY **ppkey)
@@ -114,6 +115,7 @@ EVP_PKEY_paramgen(EVP_PKEY_CTX *ctx, EVP_PKEY **ppkey)
         }
         return ret;
 }
+LCRYPTO_ALIAS(EVP_PKEY_paramgen);
 
 int
 EVP_PKEY_keygen_init(EVP_PKEY_CTX *ctx)
@@ -132,6 +134,7 @@ EVP_PKEY_keygen_init(EVP_PKEY_CTX *ctx)
                 ctx->operation = EVP_PKEY_OP_UNDEFINED;
         return ret;
 }
+LCRYPTO_ALIAS(EVP_PKEY_keygen_init);
 
 int
 EVP_PKEY_keygen(EVP_PKEY_CTX *ctx, EVP_PKEY **ppkey)
@@ -160,18 +163,21 @@ EVP_PKEY_keygen(EVP_PKEY_CTX *ctx, EVP_PKEY **ppkey)
         }
         return ret;
 }
+LCRYPTO_ALIAS(EVP_PKEY_keygen);
 
 void
 EVP_PKEY_CTX_set_cb(EVP_PKEY_CTX *ctx, EVP_PKEY_gen_cb *cb)
 {
         ctx->pkey_gencb = cb;
 }
+LCRYPTO_ALIAS(EVP_PKEY_CTX_set_cb);
 
 EVP_PKEY_gen_cb *
 EVP_PKEY_CTX_get_cb(EVP_PKEY_CTX *ctx)
 {
         return ctx->pkey_gencb;
 }
+LCRYPTO_ALIAS(EVP_PKEY_CTX_get_cb);
 
 /* "translation callback" to call EVP_PKEY_CTX callbacks using BN_GENCB
  * style callbacks.
@@ -201,6 +207,7 @@ EVP_PKEY_CTX_get_keygen_info(EVP_PKEY_CTX *ctx, int idx)
                 return 0;
         return ctx->keygen_info[idx];
 }
+LCRYPTO_ALIAS(EVP_PKEY_CTX_get_keygen_info);
 
 EVP_PKEY *
 EVP_PKEY_new_mac_key(int type, ENGINE *e, const unsigned char *key, int keylen)
@@ -223,6 +230,7 @@ merr:
         EVP_PKEY_CTX_free(mac_ctx);
         return mac_key;
 }
+LCRYPTO_ALIAS(EVP_PKEY_new_mac_key);
 
 int
 EVP_PKEY_check(EVP_PKEY_CTX *ctx)
@@ -244,6 +252,7 @@ EVP_PKEY_check(EVP_PKEY_CTX *ctx)
 
         return pkey->ameth->pkey_check(pkey);
 }
+LCRYPTO_ALIAS(EVP_PKEY_check);
 
 int
 EVP_PKEY_public_check(EVP_PKEY_CTX *ctx)
@@ -265,6 +274,7 @@ EVP_PKEY_public_check(EVP_PKEY_CTX *ctx)
 
         return pkey->ameth->pkey_public_check(pkey);
 }
+LCRYPTO_ALIAS(EVP_PKEY_public_check);
 
 int
 EVP_PKEY_param_check(EVP_PKEY_CTX *ctx)
@@ -286,3 +296,4 @@ EVP_PKEY_param_check(EVP_PKEY_CTX *ctx)
 
         return pkey->ameth->pkey_param_check(pkey);
 }
+LCRYPTO_ALIAS(EVP_PKEY_param_check);
diff --git a/src/lib/libcrypto/evp/pmeth_lib.c b/src/lib/libcrypto/evp/pmeth_lib.c
index 3341ba1e0f..cad38d4fe9 100644
--- a/src/lib/libcrypto/evp/pmeth_lib.c
+++ b/src/lib/libcrypto/evp/pmeth_lib.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: pmeth_lib.c,v 1.31 2023/06/20 14:14:00 tb Exp $ */
+/* $OpenBSD: pmeth_lib.c,v 1.32 2023/07/07 13:54:46 beck Exp $ */
 /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
  * project 2006.
  */
@@ -149,6 +149,7 @@ EVP_PKEY_meth_find(int type)
 
         return NULL;
 }
+LCRYPTO_ALIAS(EVP_PKEY_meth_find);
 
 static EVP_PKEY_CTX *
 evp_pkey_ctx_new(EVP_PKEY *pkey, ENGINE *engine, int id)
@@ -225,6 +226,7 @@ EVP_PKEY_meth_new(int id, int flags)
 
         return pmeth;
 }
+LCRYPTO_ALIAS(EVP_PKEY_meth_new);
 
 void
 EVP_PKEY_meth_get0_info(int *ppkey_id, int *pflags, const EVP_PKEY_METHOD *meth)
@@ -234,6 +236,7 @@ EVP_PKEY_meth_get0_info(int *ppkey_id, int *pflags, const EVP_PKEY_METHOD *meth)
         if (pflags)
                 *pflags = meth->flags;
 }
+LCRYPTO_ALIAS(EVP_PKEY_meth_get0_info);
 
 void
 EVP_PKEY_meth_copy(EVP_PKEY_METHOD *dst, const EVP_PKEY_METHOD *src)
@@ -248,6 +251,7 @@ EVP_PKEY_meth_copy(EVP_PKEY_METHOD *dst, const EVP_PKEY_METHOD *src)
         dst->pkey_id = preserve.pkey_id;
         dst->flags = preserve.flags;
 }
+LCRYPTO_ALIAS(EVP_PKEY_meth_copy);
 
 void
 EVP_PKEY_meth_free(EVP_PKEY_METHOD *pmeth)
@@ -255,18 +259,21 @@ EVP_PKEY_meth_free(EVP_PKEY_METHOD *pmeth)
         if (pmeth && (pmeth->flags & EVP_PKEY_FLAG_DYNAMIC))
                 free(pmeth);
 }
+LCRYPTO_ALIAS(EVP_PKEY_meth_free);
 
 EVP_PKEY_CTX *
 EVP_PKEY_CTX_new(EVP_PKEY *pkey, ENGINE *engine)
 {
         return evp_pkey_ctx_new(pkey, engine, -1);
 }
+LCRYPTO_ALIAS(EVP_PKEY_CTX_new);
 
 EVP_PKEY_CTX *
 EVP_PKEY_CTX_new_id(int id, ENGINE *engine)
 {
         return evp_pkey_ctx_new(NULL, engine, id);
 }
+LCRYPTO_ALIAS(EVP_PKEY_CTX_new_id);
 
 EVP_PKEY_CTX *
 EVP_PKEY_CTX_dup(EVP_PKEY_CTX *pctx)
@@ -308,6 +315,7 @@ EVP_PKEY_CTX_dup(EVP_PKEY_CTX *pctx)
         EVP_PKEY_CTX_free(rctx);
         return NULL;
 }
+LCRYPTO_ALIAS(EVP_PKEY_CTX_dup);
 
 int
 EVP_PKEY_meth_add0(const EVP_PKEY_METHOD *pmeth)
@@ -323,6 +331,7 @@ EVP_PKEY_meth_add0(const EVP_PKEY_METHOD *pmeth)
 
         return 1;
 }
+LCRYPTO_ALIAS(EVP_PKEY_meth_add0);
 
 void
 EVP_PKEY_CTX_free(EVP_PKEY_CTX *ctx)
@@ -338,6 +347,7 @@ EVP_PKEY_CTX_free(EVP_PKEY_CTX *ctx)
 #endif
         free(ctx);
 }
+LCRYPTO_ALIAS(EVP_PKEY_CTX_free);
 
 int
 EVP_PKEY_CTX_ctrl(EVP_PKEY_CTX *ctx, int keytype, int optype, int cmd,
@@ -370,6 +380,7 @@ EVP_PKEY_CTX_ctrl(EVP_PKEY_CTX *ctx, int keytype, int optype, int cmd,
         return ret;
 
 }
+LCRYPTO_ALIAS(EVP_PKEY_CTX_ctrl);
 
 int
 EVP_PKEY_CTX_ctrl_str(EVP_PKEY_CTX *ctx, const char *name, const char *value)
@@ -384,6 +395,7 @@ EVP_PKEY_CTX_ctrl_str(EVP_PKEY_CTX *ctx, const char *name, const char *value)
         }
         return ctx->pmeth->ctrl_str(ctx, name, value);
 }
+LCRYPTO_ALIAS(EVP_PKEY_CTX_ctrl_str);
 
 int
 EVP_PKEY_CTX_str2ctrl(EVP_PKEY_CTX *ctx, int cmd, const char *str)
@@ -434,6 +446,7 @@ EVP_PKEY_CTX_get_operation(EVP_PKEY_CTX *ctx)
 {
         return ctx->operation;
 }
+LCRYPTO_ALIAS(EVP_PKEY_CTX_get_operation);
 
 void
 EVP_PKEY_CTX_set0_keygen_info(EVP_PKEY_CTX *ctx, int *dat, int datlen)
@@ -441,42 +454,49 @@ EVP_PKEY_CTX_set0_keygen_info(EVP_PKEY_CTX *ctx, int *dat, int datlen)
         ctx->keygen_info = dat;
         ctx->keygen_info_count = datlen;
 }
+LCRYPTO_ALIAS(EVP_PKEY_CTX_set0_keygen_info);
 
 void
 EVP_PKEY_CTX_set_data(EVP_PKEY_CTX *ctx, void *data)
 {
         ctx->data = data;
 }
+LCRYPTO_ALIAS(EVP_PKEY_CTX_set_data);
 
 void *
 EVP_PKEY_CTX_get_data(EVP_PKEY_CTX *ctx)
 {
         return ctx->data;
 }
+LCRYPTO_ALIAS(EVP_PKEY_CTX_get_data);
 
 EVP_PKEY *
 EVP_PKEY_CTX_get0_pkey(EVP_PKEY_CTX *ctx)
 {
         return ctx->pkey;
 }
+LCRYPTO_ALIAS(EVP_PKEY_CTX_get0_pkey);
 
 EVP_PKEY *
 EVP_PKEY_CTX_get0_peerkey(EVP_PKEY_CTX *ctx)
 {
         return ctx->peerkey;
 }
+LCRYPTO_ALIAS(EVP_PKEY_CTX_get0_peerkey);
 
 void
 EVP_PKEY_CTX_set_app_data(EVP_PKEY_CTX *ctx, void *data)
 {
         ctx->app_data = data;
 }
+LCRYPTO_ALIAS(EVP_PKEY_CTX_set_app_data);
 
 void *
 EVP_PKEY_CTX_get_app_data(EVP_PKEY_CTX *ctx)
 {
         return ctx->app_data;
 }
+LCRYPTO_ALIAS(EVP_PKEY_CTX_get_app_data);
 
 void
 EVP_PKEY_meth_set_init(EVP_PKEY_METHOD *pmeth,
@@ -484,6 +504,7 @@ EVP_PKEY_meth_set_init(EVP_PKEY_METHOD *pmeth,
 {
         pmeth->init = init;
 }
+LCRYPTO_ALIAS(EVP_PKEY_meth_set_init);
 
 void
 EVP_PKEY_meth_set_copy(EVP_PKEY_METHOD *pmeth,
@@ -491,6 +512,7 @@ EVP_PKEY_meth_set_copy(EVP_PKEY_METHOD *pmeth,
 {
         pmeth->copy = copy;
 }
+LCRYPTO_ALIAS(EVP_PKEY_meth_set_copy);
 
 void
 EVP_PKEY_meth_set_cleanup(EVP_PKEY_METHOD *pmeth,
@@ -498,6 +520,7 @@ EVP_PKEY_meth_set_cleanup(EVP_PKEY_METHOD *pmeth,
 {
         pmeth->cleanup = cleanup;
 }
+LCRYPTO_ALIAS(EVP_PKEY_meth_set_cleanup);
 
 void
 EVP_PKEY_meth_set_paramgen(EVP_PKEY_METHOD *pmeth,
@@ -507,6 +530,7 @@ EVP_PKEY_meth_set_paramgen(EVP_PKEY_METHOD *pmeth,
         pmeth->paramgen_init = paramgen_init;
         pmeth->paramgen = paramgen;
 }
+LCRYPTO_ALIAS(EVP_PKEY_meth_set_paramgen);
 
 void
 EVP_PKEY_meth_set_keygen(EVP_PKEY_METHOD *pmeth,
@@ -516,6 +540,7 @@ EVP_PKEY_meth_set_keygen(EVP_PKEY_METHOD *pmeth,
         pmeth->keygen_init = keygen_init;
         pmeth->keygen = keygen;
 }
+LCRYPTO_ALIAS(EVP_PKEY_meth_set_keygen);
 
 void
 EVP_PKEY_meth_set_sign(EVP_PKEY_METHOD *pmeth,
@@ -526,6 +551,7 @@ EVP_PKEY_meth_set_sign(EVP_PKEY_METHOD *pmeth,
         pmeth->sign_init = sign_init;
         pmeth->sign = sign;
 }
+LCRYPTO_ALIAS(EVP_PKEY_meth_set_sign);
 
 void
 EVP_PKEY_meth_set_verify(EVP_PKEY_METHOD *pmeth,
@@ -536,6 +562,7 @@ EVP_PKEY_meth_set_verify(EVP_PKEY_METHOD *pmeth,
         pmeth->verify_init = verify_init;
         pmeth->verify = verify;
 }
+LCRYPTO_ALIAS(EVP_PKEY_meth_set_verify);
 
 void
 EVP_PKEY_meth_set_verify_recover(EVP_PKEY_METHOD *pmeth,
@@ -547,6 +574,7 @@ EVP_PKEY_meth_set_verify_recover(EVP_PKEY_METHOD *pmeth,
         pmeth->verify_recover_init = verify_recover_init;
         pmeth->verify_recover = verify_recover;
 }
+LCRYPTO_ALIAS(EVP_PKEY_meth_set_verify_recover);
 
 void
 EVP_PKEY_meth_set_signctx(EVP_PKEY_METHOD *pmeth,
@@ -557,6 +585,7 @@ EVP_PKEY_meth_set_signctx(EVP_PKEY_METHOD *pmeth,
         pmeth->signctx_init = signctx_init;
         pmeth->signctx = signctx;
 }
+LCRYPTO_ALIAS(EVP_PKEY_meth_set_signctx);
 
 void
 EVP_PKEY_meth_set_verifyctx(EVP_PKEY_METHOD *pmeth,
@@ -567,6 +596,7 @@ EVP_PKEY_meth_set_verifyctx(EVP_PKEY_METHOD *pmeth,
         pmeth->verifyctx_init = verifyctx_init;
         pmeth->verifyctx = verifyctx;
 }
+LCRYPTO_ALIAS(EVP_PKEY_meth_set_verifyctx);
 
 void
 EVP_PKEY_meth_set_encrypt(EVP_PKEY_METHOD *pmeth,
@@ -577,6 +607,7 @@ EVP_PKEY_meth_set_encrypt(EVP_PKEY_METHOD *pmeth,
         pmeth->encrypt_init = encrypt_init;
         pmeth->encrypt = encryptfn;
 }
+LCRYPTO_ALIAS(EVP_PKEY_meth_set_encrypt);
 
 void
 EVP_PKEY_meth_set_decrypt(EVP_PKEY_METHOD *pmeth,
@@ -587,6 +618,7 @@ EVP_PKEY_meth_set_decrypt(EVP_PKEY_METHOD *pmeth,
         pmeth->decrypt_init = decrypt_init;
         pmeth->decrypt = decrypt;
 }
+LCRYPTO_ALIAS(EVP_PKEY_meth_set_decrypt);
 
 void
 EVP_PKEY_meth_set_derive(EVP_PKEY_METHOD *pmeth,
@@ -596,6 +628,7 @@ EVP_PKEY_meth_set_derive(EVP_PKEY_METHOD *pmeth,
         pmeth->derive_init = derive_init;
         pmeth->derive = derive;
 }
+LCRYPTO_ALIAS(EVP_PKEY_meth_set_derive);
 
 void
 EVP_PKEY_meth_set_ctrl(EVP_PKEY_METHOD *pmeth,
@@ -605,12 +638,14 @@ EVP_PKEY_meth_set_ctrl(EVP_PKEY_METHOD *pmeth,
         pmeth->ctrl = ctrl;
         pmeth->ctrl_str = ctrl_str;
 }
+LCRYPTO_ALIAS(EVP_PKEY_meth_set_ctrl);
 
 void
 EVP_PKEY_meth_set_check(EVP_PKEY_METHOD *pmeth, int (*check)(EVP_PKEY *pkey))
 {
         pmeth->check = check;
 }
+LCRYPTO_ALIAS(EVP_PKEY_meth_set_check);
 
 void
 EVP_PKEY_meth_set_public_check(EVP_PKEY_METHOD *pmeth,
@@ -618,6 +653,7 @@ EVP_PKEY_meth_set_public_check(EVP_PKEY_METHOD *pmeth,
 {
         pmeth->public_check = public_check;
 }
+LCRYPTO_ALIAS(EVP_PKEY_meth_set_public_check);
 
 void
 EVP_PKEY_meth_set_param_check(EVP_PKEY_METHOD *pmeth,
@@ -625,3 +661,4 @@ EVP_PKEY_meth_set_param_check(EVP_PKEY_METHOD *pmeth,
 {
         pmeth->param_check = param_check;
 }
+LCRYPTO_ALIAS(EVP_PKEY_meth_set_param_check);
diff --git a/src/lib/libcrypto/hkdf/hkdf.c b/src/lib/libcrypto/hkdf/hkdf.c
index 9e0e206324..4f9c9e566a 100644
--- a/src/lib/libcrypto/hkdf/hkdf.c
+++ b/src/lib/libcrypto/hkdf/hkdf.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: hkdf.c,v 1.9 2023/06/01 02:34:23 tb Exp $ */
+/* $OpenBSD: hkdf.c,v 1.10 2023/07/07 13:54:46 beck Exp $ */
 /* Copyright (c) 2014, Google Inc.
  *
  * Permission to use, copy, modify, and/or distribute this software for any
@@ -42,6 +42,7 @@ HKDF(uint8_t *out_key, size_t out_len, const EVP_MD *digest,
 
         return 1;
 }
+LCRYPTO_ALIAS(HKDF);
 
 /* https://tools.ietf.org/html/rfc5869#section-2.2 */
 int
@@ -63,6 +64,7 @@ HKDF_extract(uint8_t *out_key, size_t *out_len,
         *out_len = len;
         return 1;
 }
+LCRYPTO_ALIAS(HKDF_extract);
 
 /* https://tools.ietf.org/html/rfc5869#section-2.3 */
 int
@@ -118,3 +120,4 @@ HKDF_expand(uint8_t *out_key, size_t out_len,
                 CRYPTOerror(ERR_R_CRYPTO_LIB);
         return ret;
 }
+LCRYPTO_ALIAS(HKDF_expand);