From ea2baf45ff427a396d0e07bc3399b0103438903c Mon Sep 17 00:00:00 2001 From: beck Date: Fri, 7 Jul 2023 13:54:45 +0000 Subject: [PATCH] Hide symbols in hkdf, evp, err, ecdsa, and ec (part 2 of commit) ok jsing@ --- lib/libcrypto/Symbols.namespace | 634 ++++++++++++++++++++++++ lib/libcrypto/ec/ec_asn1.c | 25 +- lib/libcrypto/ec/ec_check.c | 3 +- lib/libcrypto/ec/ec_curve.c | 6 +- lib/libcrypto/ec/ec_cvt.c | 3 +- lib/libcrypto/ec/ec_err.c | 3 +- lib/libcrypto/ec/ec_key.c | 28 +- lib/libcrypto/ec/ec_kmeth.c | 20 +- lib/libcrypto/ec/ec_lib.c | 56 ++- lib/libcrypto/ec/ec_oct.c | 6 +- lib/libcrypto/ec/ec_print.c | 6 +- lib/libcrypto/ec/eck_prn.c | 8 +- lib/libcrypto/ec/ecp_mont.c | 3 +- lib/libcrypto/ec/ecp_smpl.c | 3 +- lib/libcrypto/ecdh/ecdh.c | 4 +- lib/libcrypto/ecdh/ech_err.c | 3 +- lib/libcrypto/ecdh/ech_lib.c | 9 +- lib/libcrypto/ecdsa/ecdsa.c | 18 +- lib/libcrypto/ecdsa/ecs_err.c | 3 +- lib/libcrypto/ecdsa/ecs_lib.c | 9 +- lib/libcrypto/err/err.c | 35 +- lib/libcrypto/err/err_all.c | 3 +- lib/libcrypto/err/err_prn.c | 5 +- lib/libcrypto/evp/bio_b64.c | 3 +- lib/libcrypto/evp/bio_enc.c | 4 +- lib/libcrypto/evp/bio_md.c | 3 +- lib/libcrypto/evp/c_all.c | 6 +- lib/libcrypto/evp/cipher_method_lib.c | 14 +- lib/libcrypto/evp/digest.c | 18 +- lib/libcrypto/evp/e_aes.c | 33 +- lib/libcrypto/evp/e_aes_cbc_hmac_sha1.c | 6 +- lib/libcrypto/evp/e_bf.c | 6 +- lib/libcrypto/evp/e_camellia.c | 20 +- lib/libcrypto/evp/e_cast.c | 6 +- lib/libcrypto/evp/e_chacha.c | 3 +- lib/libcrypto/evp/e_chacha20poly1305.c | 5 +- lib/libcrypto/evp/e_des.c | 8 +- lib/libcrypto/evp/e_des3.c | 14 +- lib/libcrypto/evp/e_gost2814789.c | 5 +- lib/libcrypto/evp/e_idea.c | 6 +- lib/libcrypto/evp/e_null.c | 3 +- lib/libcrypto/evp/e_rc2.c | 8 +- lib/libcrypto/evp/e_rc4.c | 4 +- lib/libcrypto/evp/e_rc4_hmac_md5.c | 3 +- lib/libcrypto/evp/e_sm4.c | 7 +- lib/libcrypto/evp/e_xcbc_d.c | 3 +- lib/libcrypto/evp/encode.c | 12 +- lib/libcrypto/evp/evp_aead.c | 12 +- lib/libcrypto/evp/evp_enc.c | 27 +- lib/libcrypto/evp/evp_err.c | 3 +- lib/libcrypto/evp/evp_key.c | 7 +- lib/libcrypto/evp/evp_lib.c | 55 +- lib/libcrypto/evp/evp_pbe.c | 7 +- lib/libcrypto/evp/evp_pkey.c | 13 +- lib/libcrypto/evp/m_gost2814789.c | 3 +- lib/libcrypto/evp/m_gostr341194.c | 3 +- lib/libcrypto/evp/m_md4.c | 3 +- lib/libcrypto/evp/m_md5.c | 3 +- lib/libcrypto/evp/m_md5_sha1.c | 3 +- lib/libcrypto/evp/m_null.c | 3 +- lib/libcrypto/evp/m_ripemd.c | 3 +- lib/libcrypto/evp/m_sha1.c | 9 +- lib/libcrypto/evp/m_sha3.c | 6 +- lib/libcrypto/evp/m_sigver.c | 8 +- lib/libcrypto/evp/m_sm3.c | 3 +- lib/libcrypto/evp/m_streebog.c | 4 +- lib/libcrypto/evp/m_wp.c | 3 +- lib/libcrypto/evp/names.c | 11 +- lib/libcrypto/evp/p5_crpt.c | 4 +- lib/libcrypto/evp/p5_crpt2.c | 5 +- lib/libcrypto/evp/p_dec.c | 3 +- lib/libcrypto/evp/p_enc.c | 3 +- lib/libcrypto/evp/p_lib.c | 42 +- lib/libcrypto/evp/p_open.c | 4 +- lib/libcrypto/evp/p_seal.c | 4 +- lib/libcrypto/evp/p_sign.c | 3 +- lib/libcrypto/evp/p_verify.c | 3 +- lib/libcrypto/evp/pmeth_fn.c | 15 +- lib/libcrypto/evp/pmeth_gn.c | 13 +- lib/libcrypto/evp/pmeth_lib.c | 39 +- lib/libcrypto/hkdf/hkdf.c | 5 +- 81 files changed, 1345 insertions(+), 80 deletions(-) diff --git a/lib/libcrypto/Symbols.namespace b/lib/libcrypto/Symbols.namespace index ff5c1f6bd6b..c266ee0aabe 100644 --- a/lib/libcrypto/Symbols.namespace +++ b/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/lib/libcrypto/ec/ec_asn1.c b/lib/libcrypto/ec/ec_asn1.c index 6aedab97747..0435f0a75f8 100644 --- a/lib/libcrypto/ec/ec_asn1.c +++ b/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/lib/libcrypto/ec/ec_check.c b/lib/libcrypto/ec/ec_check.c index 4a38dec539e..0f98ef613c9 100644 --- a/lib/libcrypto/ec/ec_check.c +++ b/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/lib/libcrypto/ec/ec_curve.c b/lib/libcrypto/ec/ec_curve.c index a8a1e4d5221..9d19628b3e0 100644 --- a/lib/libcrypto/ec/ec_curve.c +++ b/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/lib/libcrypto/ec/ec_cvt.c b/lib/libcrypto/ec/ec_cvt.c index 90e74007399..5b196dd6719 100644 --- a/lib/libcrypto/ec/ec_cvt.c +++ b/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/lib/libcrypto/ec/ec_err.c b/lib/libcrypto/ec/ec_err.c index d10b8e6f7d1..d797b937c27 100644 --- a/lib/libcrypto/ec/ec_err.c +++ b/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/lib/libcrypto/ec/ec_key.c b/lib/libcrypto/ec/ec_key.c index a15d06b0197..e5ff1898034 100644 --- a/lib/libcrypto/ec/ec_key.c +++ b/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/lib/libcrypto/ec/ec_kmeth.c b/lib/libcrypto/ec/ec_kmeth.c index ec45e679d9c..3e997f8a5e5 100644 --- a/lib/libcrypto/ec/ec_kmeth.c +++ b/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/lib/libcrypto/ec/ec_lib.c b/lib/libcrypto/ec/ec_lib.c index 8cea0bb95bf..3db1ca2f07b 100644 --- a/lib/libcrypto/ec/ec_lib.c +++ b/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/lib/libcrypto/ec/ec_oct.c b/lib/libcrypto/ec/ec_oct.c index f9de2f13a17..b9bc62a4e3d 100644 --- a/lib/libcrypto/ec/ec_oct.c +++ b/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/lib/libcrypto/ec/ec_print.c b/lib/libcrypto/ec/ec_print.c index da33c4eccdd..312770f66c9 100644 --- a/lib/libcrypto/ec/ec_print.c +++ b/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/lib/libcrypto/ec/eck_prn.c b/lib/libcrypto/ec/eck_prn.c index f65b74518bb..6e89bfa739a 100644 --- a/lib/libcrypto/ec/eck_prn.c +++ b/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/lib/libcrypto/ec/ecp_mont.c b/lib/libcrypto/ec/ecp_mont.c index b1138556039..76d1f578ee0 100644 --- a/lib/libcrypto/ec/ecp_mont.c +++ b/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/lib/libcrypto/ec/ecp_smpl.c b/lib/libcrypto/ec/ecp_smpl.c index d3ee9f5d92c..9aa9af11f30 100644 --- a/lib/libcrypto/ec/ecp_smpl.c +++ b/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 * 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/lib/libcrypto/ecdh/ecdh.c b/lib/libcrypto/ecdh/ecdh.c index 11795640303..0781c30e095 100644 --- a/lib/libcrypto/ecdh/ecdh.c +++ b/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/lib/libcrypto/ecdh/ech_err.c b/lib/libcrypto/ecdh/ech_err.c index e0cfddfe9c1..1b194fe0fb9 100644 --- a/lib/libcrypto/ecdh/ech_err.c +++ b/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/lib/libcrypto/ecdh/ech_lib.c b/lib/libcrypto/ecdh/ech_lib.c index 52019b01c13..c8e5744c0ac 100644 --- a/lib/libcrypto/ecdh/ech_lib.c +++ b/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/lib/libcrypto/ecdsa/ecdsa.c b/lib/libcrypto/ecdsa/ecdsa.c index b9c7ea6381f..5a93b84637e 100644 --- a/lib/libcrypto/ecdsa/ecdsa.c +++ b/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/lib/libcrypto/ecdsa/ecs_err.c b/lib/libcrypto/ecdsa/ecs_err.c index c839c35221f..54d2f3f6efd 100644 --- a/lib/libcrypto/ecdsa/ecs_err.c +++ b/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/lib/libcrypto/ecdsa/ecs_lib.c b/lib/libcrypto/ecdsa/ecs_lib.c index ed02b552c93..e3e67ba07da 100644 --- a/lib/libcrypto/ecdsa/ecs_lib.c +++ b/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/lib/libcrypto/err/err.c b/lib/libcrypto/err/err.c index 365eae0e909..c513e45f9b6 100644 --- a/lib/libcrypto/err/err.c +++ b/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/lib/libcrypto/err/err_all.c b/lib/libcrypto/err/err_all.c index 9a46e93c24e..12a0fcd3296 100644 --- a/lib/libcrypto/err/err_all.c +++ b/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/lib/libcrypto/err/err_prn.c b/lib/libcrypto/err/err_prn.c index 6b5c455f069..d60cfdcb92a 100644 --- a/lib/libcrypto/err/err_prn.c +++ b/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/lib/libcrypto/evp/bio_b64.c b/lib/libcrypto/evp/bio_b64.c index 8880a28375e..5eceda09938 100644 --- a/lib/libcrypto/evp/bio_b64.c +++ b/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/lib/libcrypto/evp/bio_enc.c b/lib/libcrypto/evp/bio_enc.c index 098b1ea32b2..747e64ed7ff 100644 --- a/lib/libcrypto/evp/bio_enc.c +++ b/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/lib/libcrypto/evp/bio_md.c b/lib/libcrypto/evp/bio_md.c index 4b7ca44551d..83d6c3732cd 100644 --- a/lib/libcrypto/evp/bio_md.c +++ b/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/lib/libcrypto/evp/c_all.c b/lib/libcrypto/evp/c_all.c index 936d7e810f5..5efcd5f2377 100644 --- a/lib/libcrypto/evp/c_all.c +++ b/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/lib/libcrypto/evp/cipher_method_lib.c b/lib/libcrypto/evp/cipher_method_lib.c index 55dc6b788c3..9e4fd483a37 100644 --- a/lib/libcrypto/evp/cipher_method_lib.c +++ b/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/lib/libcrypto/evp/digest.c b/lib/libcrypto/evp/digest.c index 7c129f025d8..6615aa4a359 100644 --- a/lib/libcrypto/evp/digest.c +++ b/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/lib/libcrypto/evp/e_aes.c b/lib/libcrypto/evp/e_aes.c index 790b26384d0..35c8d944edb 100644 --- a/lib/libcrypto/evp/e_aes.c +++ b/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/lib/libcrypto/evp/e_aes_cbc_hmac_sha1.c b/lib/libcrypto/evp/e_aes_cbc_hmac_sha1.c index 9cde3861509..b905b359c9c 100644 --- a/lib/libcrypto/evp/e_aes_cbc_hmac_sha1.c +++ b/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/lib/libcrypto/evp/e_bf.c b/lib/libcrypto/evp/e_bf.c index c2ab3178a50..4e671fab3e5 100644 --- a/lib/libcrypto/evp/e_bf.c +++ b/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/lib/libcrypto/evp/e_camellia.c b/lib/libcrypto/evp/e_camellia.c index 884f8cef2aa..0ab6e9ca604 100644 --- a/lib/libcrypto/evp/e_camellia.c +++ b/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/lib/libcrypto/evp/e_cast.c b/lib/libcrypto/evp/e_cast.c index 98683e1d010..8f62ba6f29d 100644 --- a/lib/libcrypto/evp/e_cast.c +++ b/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/lib/libcrypto/evp/e_chacha.c b/lib/libcrypto/evp/e_chacha.c index f27ed1d37d6..f781d663392 100644 --- a/lib/libcrypto/evp/e_chacha.c +++ b/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 * @@ -74,5 +74,6 @@ EVP_chacha20(void) { return (&chacha20_cipher); } +LCRYPTO_ALIAS(EVP_chacha20); #endif diff --git a/lib/libcrypto/evp/e_chacha20poly1305.c b/lib/libcrypto/evp/e_chacha20poly1305.c index 1bd04c1f1f4..4b8f47cefce 100644 --- a/lib/libcrypto/evp/e_chacha20poly1305.c +++ b/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 @@ -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/lib/libcrypto/evp/e_des.c b/lib/libcrypto/evp/e_des.c index dffabc81250..c87de1a690b 100644 --- a/lib/libcrypto/evp/e_des.c +++ b/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/lib/libcrypto/evp/e_des3.c b/lib/libcrypto/evp/e_des3.c index d6c7537aeab..d345c354c03 100644 --- a/lib/libcrypto/evp/e_des3.c +++ b/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/lib/libcrypto/evp/e_gost2814789.c b/lib/libcrypto/evp/e_gost2814789.c index 6344a11e9b4..fdbc6628100 100644 --- a/lib/libcrypto/evp/e_gost2814789.c +++ b/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 * 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/lib/libcrypto/evp/e_idea.c b/lib/libcrypto/evp/e_idea.c index b8349ee9cbf..e330888ba6b 100644 --- a/lib/libcrypto/evp/e_idea.c +++ b/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/lib/libcrypto/evp/e_null.c b/lib/libcrypto/evp/e_null.c index ddd633dc7cd..3daadb1479b 100644 --- a/lib/libcrypto/evp/e_null.c +++ b/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/lib/libcrypto/evp/e_rc2.c b/lib/libcrypto/evp/e_rc2.c index 78697d08c6b..540c94cdfd5 100644 --- a/lib/libcrypto/evp/e_rc2.c +++ b/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/lib/libcrypto/evp/e_rc4.c b/lib/libcrypto/evp/e_rc4.c index 7afc6af9cd2..d79bfa729a7 100644 --- a/lib/libcrypto/evp/e_rc4.c +++ b/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/lib/libcrypto/evp/e_rc4_hmac_md5.c b/lib/libcrypto/evp/e_rc4_hmac_md5.c index b3be57d5f2e..1d0bced2dfd 100644 --- a/lib/libcrypto/evp/e_rc4_hmac_md5.c +++ b/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/lib/libcrypto/evp/e_sm4.c b/lib/libcrypto/evp/e_sm4.c index 0d37448109c..705a914821b 100644 --- a/lib/libcrypto/evp/e_sm4.c +++ b/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/lib/libcrypto/evp/e_xcbc_d.c b/lib/libcrypto/evp/e_xcbc_d.c index bbbc3a1ee90..c7810a2c22e 100644 --- a/lib/libcrypto/evp/e_xcbc_d.c +++ b/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/lib/libcrypto/evp/encode.c b/lib/libcrypto/evp/encode.c index 718bdb5fc40..10cb51217a8 100644 --- a/lib/libcrypto/evp/encode.c +++ b/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/lib/libcrypto/evp/evp_aead.c b/lib/libcrypto/evp/evp_aead.c index 58f1c8722d7..8b39c7f9238 100644 --- a/lib/libcrypto/evp/evp_aead.c +++ b/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/lib/libcrypto/evp/evp_enc.c b/lib/libcrypto/evp/evp_enc.c index df818e3a621..f9b8deddf59 100644 --- a/lib/libcrypto/evp/evp_enc.c +++ b/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/lib/libcrypto/evp/evp_err.c b/lib/libcrypto/evp/evp_err.c index 9cf89f47fb4..8835215c143 100644 --- a/lib/libcrypto/evp/evp_err.c +++ b/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/lib/libcrypto/evp/evp_key.c b/lib/libcrypto/evp/evp_key.c index 6fc8588cde4..148fd2fe92e 100644 --- a/lib/libcrypto/evp/evp_key.c +++ b/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/lib/libcrypto/evp/evp_lib.c b/lib/libcrypto/evp/evp_lib.c index f64842b86f9..d6b929c0e30 100644 --- a/lib/libcrypto/evp/evp_lib.c +++ b/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/lib/libcrypto/evp/evp_pbe.c b/lib/libcrypto/evp/evp_pbe.c index 565955524aa..5592521e620 100644 --- a/lib/libcrypto/evp/evp_pbe.c +++ b/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/lib/libcrypto/evp/evp_pkey.c b/lib/libcrypto/evp/evp_pkey.c index d2fbdee46c3..31a59e25367 100644 --- a/lib/libcrypto/evp/evp_pkey.c +++ b/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/lib/libcrypto/evp/m_gost2814789.c b/lib/libcrypto/evp/m_gost2814789.c index ca303dab9f7..69f927c5a70 100644 --- a/lib/libcrypto/evp/m_gost2814789.c +++ b/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 * Copyright (c) 2005-2006 Cryptocom LTD @@ -110,4 +110,5 @@ EVP_gost2814789imit(void) { return (&gost2814789imit_md); } +LCRYPTO_ALIAS(EVP_gost2814789imit); #endif diff --git a/lib/libcrypto/evp/m_gostr341194.c b/lib/libcrypto/evp/m_gostr341194.c index 33e96a5a2c4..e2a65a3147b 100644 --- a/lib/libcrypto/evp/m_gostr341194.c +++ b/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 * Copyright (c) 2005-2006 Cryptocom LTD @@ -97,4 +97,5 @@ EVP_gostr341194(void) { return (&gostr341194_md); } +LCRYPTO_ALIAS(EVP_gostr341194); #endif diff --git a/lib/libcrypto/evp/m_md4.c b/lib/libcrypto/evp/m_md4.c index c1e0256b38f..d86ed426d3b 100644 --- a/lib/libcrypto/evp/m_md4.c +++ b/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/lib/libcrypto/evp/m_md5.c b/lib/libcrypto/evp/m_md5.c index b66b25bab8e..18a78016c6d 100644 --- a/lib/libcrypto/evp/m_md5.c +++ b/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/lib/libcrypto/evp/m_md5_sha1.c b/lib/libcrypto/evp/m_md5_sha1.c index b1944b881e3..32a6f56a1b0 100644 --- a/lib/libcrypto/evp/m_md5_sha1.c +++ b/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 * @@ -87,3 +87,4 @@ EVP_md5_sha1(void) { return &md5_sha1_md; } +LCRYPTO_ALIAS(EVP_md5_sha1); diff --git a/lib/libcrypto/evp/m_null.c b/lib/libcrypto/evp/m_null.c index d09c0007f3c..884a47927e5 100644 --- a/lib/libcrypto/evp/m_null.c +++ b/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/lib/libcrypto/evp/m_ripemd.c b/lib/libcrypto/evp/m_ripemd.c index 896de59d1cd..3cba1dcf1b4 100644 --- a/lib/libcrypto/evp/m_ripemd.c +++ b/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/lib/libcrypto/evp/m_sha1.c b/lib/libcrypto/evp/m_sha1.c index b7f4705d861..631e19549e7 100644 --- a/lib/libcrypto/evp/m_sha1.c +++ b/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/lib/libcrypto/evp/m_sha3.c b/lib/libcrypto/evp/m_sha3.c index 9944ec979d5..9137629823e 100644 --- a/lib/libcrypto/evp/m_sha3.c +++ b/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 * @@ -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/lib/libcrypto/evp/m_sigver.c b/lib/libcrypto/evp/m_sigver.c index 49b1ce29b7a..950e4a2a2fc 100644 --- a/lib/libcrypto/evp/m_sigver.c +++ b/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/lib/libcrypto/evp/m_sm3.c b/lib/libcrypto/evp/m_sm3.c index bf0ef527eb0..169a492d68b 100644 --- a/lib/libcrypto/evp/m_sm3.c +++ b/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/lib/libcrypto/evp/m_streebog.c b/lib/libcrypto/evp/m_streebog.c index 5a0dece5993..ce41e4ca8f4 100644 --- a/lib/libcrypto/evp/m_streebog.c +++ b/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 * 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/lib/libcrypto/evp/m_wp.c b/lib/libcrypto/evp/m_wp.c index 2e0b46d5d33..9bd43370e61 100644 --- a/lib/libcrypto/evp/m_wp.c +++ b/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 @@ -50,4 +50,5 @@ EVP_whirlpool(void) { return (&whirlpool_md); } +LCRYPTO_ALIAS(EVP_whirlpool); #endif diff --git a/lib/libcrypto/evp/names.c b/lib/libcrypto/evp/names.c index 10ce13bb89f..c6109a5356b 100644 --- a/lib/libcrypto/evp/names.c +++ b/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/lib/libcrypto/evp/p5_crpt.c b/lib/libcrypto/evp/p5_crpt.c index e85a60f50ea..cf30ad91768 100644 --- a/lib/libcrypto/evp/p5_crpt.c +++ b/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/lib/libcrypto/evp/p5_crpt2.c b/lib/libcrypto/evp/p5_crpt2.c index 6c0cf529a48..a6fcc30fa40 100644 --- a/lib/libcrypto/evp/p5_crpt2.c +++ b/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/lib/libcrypto/evp/p_dec.c b/lib/libcrypto/evp/p_dec.c index 33dd3019118..7225606c313 100644 --- a/lib/libcrypto/evp/p_dec.c +++ b/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/lib/libcrypto/evp/p_enc.c b/lib/libcrypto/evp/p_enc.c index 4685f55cade..c2a16234e87 100644 --- a/lib/libcrypto/evp/p_enc.c +++ b/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/lib/libcrypto/evp/p_lib.c b/lib/libcrypto/evp/p_lib.c index e1760122c67..325fb605dfd 100644 --- a/lib/libcrypto/evp/p_lib.c +++ b/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/lib/libcrypto/evp/p_open.c b/lib/libcrypto/evp/p_open.c index bce900b9ab8..5ab36b8ef5c 100644 --- a/lib/libcrypto/evp/p_open.c +++ b/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/lib/libcrypto/evp/p_seal.c b/lib/libcrypto/evp/p_seal.c index 8b9740fbcdc..52521e133b9 100644 --- a/lib/libcrypto/evp/p_seal.c +++ b/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/lib/libcrypto/evp/p_sign.c b/lib/libcrypto/evp/p_sign.c index 1f78d1efef4..13655b076f1 100644 --- a/lib/libcrypto/evp/p_sign.c +++ b/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/lib/libcrypto/evp/p_verify.c b/lib/libcrypto/evp/p_verify.c index 545715325d2..601b44e5e0b 100644 --- a/lib/libcrypto/evp/p_verify.c +++ b/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/lib/libcrypto/evp/pmeth_fn.c b/lib/libcrypto/evp/pmeth_fn.c index cab1dfab6f4..3025005034e 100644 --- a/lib/libcrypto/evp/pmeth_fn.c +++ b/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/lib/libcrypto/evp/pmeth_gn.c b/lib/libcrypto/evp/pmeth_gn.c index d31bb7c0b48..2b835cd8fe7 100644 --- a/lib/libcrypto/evp/pmeth_gn.c +++ b/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/lib/libcrypto/evp/pmeth_lib.c b/lib/libcrypto/evp/pmeth_lib.c index 3341ba1e0f7..cad38d4fe96 100644 --- a/lib/libcrypto/evp/pmeth_lib.c +++ b/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/lib/libcrypto/hkdf/hkdf.c b/lib/libcrypto/hkdf/hkdf.c index 9e0e2063246..4f9c9e566a0 100644 --- a/lib/libcrypto/hkdf/hkdf.c +++ b/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); -- 2.20.1