_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
-/* $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.
*/
{
return 0;
}
+LCRYPTO_ALIAS(EC_GROUP_get_basis_type);
/* some structures needed for the asn1 encoding */
typedef struct x9_62_pentanomial_st {
{
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,
{
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,
{
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[] = {
{
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[] = {
{
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 */
ECPKPARAMETERS_free(params);
return (group);
}
+LCRYPTO_ALIAS(d2i_ECPKParameters);
int
i2d_ECPKParameters(const EC_GROUP *a, unsigned char **out)
ECPKPARAMETERS_free(tmp);
return (ret);
}
+LCRYPTO_ALIAS(i2d_ECPKParameters);
/* some EC_KEY functions */
return (NULL);
}
+LCRYPTO_ALIAS(d2i_ECPrivateKey);
int
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)
}
return i2d_ECPKParameters(a->group, out);
}
+LCRYPTO_ALIAS(i2d_ECParameters);
EC_KEY *
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)
*in += len;
return ret;
}
+LCRYPTO_ALIAS(o2i_ECPublicKey);
int
i2o_ECPublicKey(const EC_KEY *a, unsigned char **out)
*out += buf_len;
return buf_len;
}
+LCRYPTO_ALIAS(i2o_ECPublicKey);
-/* $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.
*
return ret;
}
+LCRYPTO_ALIAS(EC_GROUP_check);
-/* $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.
*/
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)
return CURVE_LIST_LENGTH;
}
+LCRYPTO_ALIAS(EC_get_builtin_curves);
static const struct {
const char *name;
return NULL;
}
+LCRYPTO_ALIAS(EC_curve_nid2nist);
int
EC_curve_nist2nid(const char *name)
return NID_undef;
}
+LCRYPTO_ALIAS(EC_curve_nist2nid);
-/* $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.
*/
{
return ec_group_new_curve(EC_GFp_mont_method(), p, a, b, ctx);
}
+LCRYPTO_ALIAS(EC_GROUP_new_curve_GFp);
-/* $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.
*
}
#endif
}
+LCRYPTO_ALIAS(ERR_load_EC_strings);
-/* $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.
*/
{
return EC_KEY_new_method(NULL);
}
+LCRYPTO_ALIAS(EC_KEY_new);
EC_KEY *
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)
freezero(r, sizeof(EC_KEY));
}
+LCRYPTO_ALIAS(EC_KEY_free);
EC_KEY *
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)
}
return ret;
}
+LCRYPTO_ALIAS(EC_KEY_dup);
int
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)
ECerror(EC_R_NOT_IMPLEMENTED);
return 0;
}
+LCRYPTO_ALIAS(EC_KEY_generate_key);
int
ec_key_gen(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)
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)
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)
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)
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)
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)
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)
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);
-/* $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.
{
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)
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)
return meth->init(key);
return 1;
}
+LCRYPTO_ALIAS(EC_KEY_set_method);
EC_KEY *
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)
ret->flags |= EC_KEY_METHOD_DYNAMIC;
return ret;
}
+LCRYPTO_ALIAS(EC_KEY_METHOD_new);
void
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,
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,
{
meth->compute_key = ckey;
}
+LCRYPTO_ALIAS(EC_KEY_METHOD_set_compute_key);
void
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,
meth->verify = verify;
meth->verify_sig = verify_sig;
}
+LCRYPTO_ALIAS(EC_KEY_METHOD_set_verify);
void
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,
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,
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,
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,
if (pverify_sig != NULL)
*pverify_sig = meth->verify_sig;
}
+LCRYPTO_ALIAS(EC_KEY_METHOD_get_verify);
-/* $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.
*/
}
return ret;
}
+LCRYPTO_ALIAS(EC_GROUP_new);
void
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)
return dest->meth->group_copy(dest, src);
}
+LCRYPTO_ALIAS(EC_GROUP_copy);
EC_GROUP *
}
return t;
}
+LCRYPTO_ALIAS(EC_GROUP_dup);
const EC_METHOD *
{
return group->meth;
}
+LCRYPTO_ALIAS(EC_GROUP_method_of);
int
{
return meth->field_type;
}
+LCRYPTO_ALIAS(EC_METHOD_get_field_type);
/*
* If there is a user-provided cofactor, sanity check and use it. Otherwise
return 1;
}
+LCRYPTO_ALIAS(EC_GROUP_set_generator);
const EC_POINT *
{
return group->generator;
}
+LCRYPTO_ALIAS(EC_GROUP_get0_generator);
int
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)
{
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)
return !BN_is_zero(&group->cofactor);
}
+LCRYPTO_ALIAS(EC_GROUP_get_cofactor);
void
{
group->curve_name = nid;
}
+LCRYPTO_ALIAS(EC_GROUP_set_curve_name);
int
{
return group->curve_name;
}
+LCRYPTO_ALIAS(EC_GROUP_get_curve_name);
void
{
group->asn1_flag = flag;
}
+LCRYPTO_ALIAS(EC_GROUP_set_asn1_flag);
int
{
return group->asn1_flag;
}
+LCRYPTO_ALIAS(EC_GROUP_get_asn1_flag);
void
{
group->asn1_form = form;
}
+LCRYPTO_ALIAS(EC_GROUP_set_point_conversion_form);
point_conversion_form_t
{
return group->asn1_form;
}
+LCRYPTO_ALIAS(EC_GROUP_get_point_conversion_form);
size_t
return len;
}
+LCRYPTO_ALIAS(EC_GROUP_set_seed);
unsigned char *
{
return group->seed;
}
+LCRYPTO_ALIAS(EC_GROUP_get0_seed);
size_t
{
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,
return ret;
}
+LCRYPTO_ALIAS(EC_GROUP_set_curve);
int
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,
{
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,
{
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)
}
return group->meth->group_get_degree(group);
}
+LCRYPTO_ALIAS(EC_GROUP_get_degree);
int
return ret;
}
+LCRYPTO_ALIAS(EC_GROUP_check_discriminant);
int
BN_CTX_free(ctx);
return -1;
}
+LCRYPTO_ALIAS(EC_GROUP_cmp);
/*
* Coordinate blinding for EC_POINT.
}
return ret;
}
+LCRYPTO_ALIAS(EC_POINT_new);
void
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)
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)
} 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)
}
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,
{
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,
{
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,
return ret;
}
+LCRYPTO_ALIAS(EC_POINT_set_affine_coordinates);
int
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,
return ret;
}
+LCRYPTO_ALIAS(EC_POINT_get_affine_coordinates);
int
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,
return ret;
}
+LCRYPTO_ALIAS(EC_POINT_add);
int
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)
return ret;
}
+LCRYPTO_ALIAS(EC_POINT_invert);
int
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,
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,
return ret;
}
+LCRYPTO_ALIAS(EC_POINT_cmp);
int
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[],
return ret;
}
+LCRYPTO_ALIAS(EC_POINTs_make_affine);
int
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,
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)
return dup;
}
+LCRYPTO_ALIAS(ECParameters_dup);
-/* $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.
*/
return ret;
}
+LCRYPTO_ALIAS(EC_POINT_set_compressed_coordinates);
int
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,
return ret;
}
+LCRYPTO_ALIAS(EC_POINT_point2oct);
int
EC_POINT_oct2point(const EC_GROUP *group, EC_POINT *point,
return ret;
}
+LCRYPTO_ALIAS(EC_POINT_oct2point);
-/* $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.
*
return ret;
}
+LCRYPTO_ALIAS(EC_POINT_point2bn);
EC_POINT *
EC_POINT_bn2point(const EC_GROUP *group,
free(buf);
return ret;
}
+LCRYPTO_ALIAS(EC_POINT_bn2point);
static const char *HEX_DIGITS = "0123456789ABCDEF";
return ret;
}
+LCRYPTO_ALIAS(EC_POINT_point2hex);
EC_POINT *
EC_POINT_hex2point(const EC_GROUP *group, const char *buf,
return ret;
}
+LCRYPTO_ALIAS(EC_POINT_hex2point);
-/* $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.
*/
BIO_free(b);
return (ret);
}
+LCRYPTO_ALIAS(ECPKParameters_print_fp);
int
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)
BIO_free(b);
return (ret);
}
+LCRYPTO_ALIAS(ECParameters_print_fp);
int
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)
EVP_PKEY_free(pk);
return ret;
}
+LCRYPTO_ALIAS(ECParameters_print);
static int
print_bin(BIO *fp, const char *str, const unsigned char *num,
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,
-/* $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.
*/
{
return &ec_GFp_mont_method;
}
+LCRYPTO_ALIAS(EC_GFp_mont_method);
-/* $OpenBSD: ecp_smpl.c,v 1.45 2023/06/30 18:19:35 tb Exp $ */
+/* $OpenBSD: ecp_smpl.c,v 1.46 2023/07/07 13:54:45 beck Exp $ */
/* Includes code written by Lenka Fibikova <fibikova@exp-math.uni-essen.de>
* for the OpenSSL project.
* Includes code written by Bodo Moeller for the OpenSSL project.
{
return &ec_GFp_simple_method;
}
+LCRYPTO_ALIAS(EC_GFp_simple_method);
-/* $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.
*
}
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);
-/* $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.
*
}
#endif
}
+LCRYPTO_ALIAS(ERR_load_ECDH_strings);
-/* $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.
*
{
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)
}
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,
{
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);
-/* $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.
*
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)
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)
sig->s = s;
return 1;
}
+LCRYPTO_ALIAS(ECDSA_SIG_set0);
int
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.
{
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,
}
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,
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,
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,
}
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,
}
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,
}
return key->meth->verify(type, digest, digest_len, sigbuf, sig_len, key);
}
+LCRYPTO_ALIAS(ECDSA_verify);
-/* $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.
*
}
#endif
}
+LCRYPTO_ALIAS(ERR_load_ECDSA_strings);
-/* $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.
*
{
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)
}
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,
{
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);
-/* $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.
*
err_fns_check();
return err_fns;
}
+LCRYPTO_ALIAS(ERR_get_implementation);
int
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. */
(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)
ERR_load_ERR_strings();
err_load_strings(lib, str);
}
+LCRYPTO_ALIAS(ERR_load_strings);
void
ERR_unload_strings(int lib, ERR_STRING_DATA *str)
str++;
}
}
+LCRYPTO_ALIAS(ERR_unload_strings);
void
ERR_free_strings(void)
err_fns_check();
ERRFN(err_del)();
}
+LCRYPTO_ALIAS(ERR_free_strings);
/********************************************************/
err_clear_data(es, es->top);
errno = save_errno;
}
+LCRYPTO_ALIAS(ERR_put_error);
void
ERR_clear_error(void)
}
es->top = es->bottom = 0;
}
+LCRYPTO_ALIAS(ERR_clear_error);
unsigned long
{
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,
{
return (get_error_values(1, 0, file, line, data, flags));
}
+LCRYPTO_ALIAS(ERR_get_error_line_data);
unsigned long
{
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,
{
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,
{
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,
}
}
}
+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
return ret;
}
+LCRYPTO_ALIAS(ERR_error_string);
LHASH_OF(ERR_STRING_DATA) *ERR_get_string_table(void)
{
err_fns_check();
ERRFN(thread_release)(hash);
}
+LCRYPTO_ALIAS(ERR_release_err_state_table);
const char *
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)
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)
}
return ((p == NULL) ? NULL : p->string);
}
+LCRYPTO_ALIAS(ERR_reason_error_string);
void
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)
}
return ret;
}
+LCRYPTO_ALIAS(ERR_get_state);
int
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)
es->err_data[i] = data;
es->err_data_flags[i] = flags;
}
+LCRYPTO_ALIAS(ERR_set_error_data);
void
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)
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, ...)
ERR_add_error_vdata(num, args);
va_end(args);
}
+LCRYPTO_ALIAS(ERR_add_error_data);
int
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)
es->err_flags[es->top]&=~ERR_FLAG_MARK;
return 1;
}
+LCRYPTO_ALIAS(ERR_pop_to_mark);
void
err_clear_last_constant_time(int clear)
-/* $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.
*
static pthread_once_t loaded = PTHREAD_ONCE_INIT;
(void) pthread_once(&loaded, ERR_load_crypto_strings_internal);
}
+LCRYPTO_ALIAS(ERR_load_crypto_strings);
-/* $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.
*
break; /* abort outputting the error report */
}
}
+LCRYPTO_ALIAS(ERR_print_errors_cb);
static int
print_fp(const char *str, size_t len, void *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)
{
ERR_print_errors_cb(print_bio, bp);
}
+LCRYPTO_ALIAS(ERR_print_errors);
-/* $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.
*
{
return (&methods_b64);
}
+LCRYPTO_ALIAS(BIO_f_base64);
static int
b64_new(BIO *bi)
-/* $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.
*
{
return (&methods_enc);
}
+LCRYPTO_ALIAS(BIO_f_cipher);
static int
enc_new(BIO *bi)
return 1;
}
+LCRYPTO_ALIAS(BIO_set_cipher);
-/* $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.
*
{
return (&methods_md);
}
+LCRYPTO_ALIAS(BIO_f_md);
static int
md_new(BIO *bi)
-/* $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.
*
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)
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)
OpenSSL_add_all_ciphers();
OpenSSL_add_all_digests();
}
+LCRYPTO_ALIAS(OPENSSL_add_all_algorithms_noconf);
void
OPENSSL_add_all_algorithms_conf(void)
OPENSSL_add_all_algorithms_noconf();
OPENSSL_config(NULL);
}
+LCRYPTO_ALIAS(OPENSSL_add_all_algorithms_conf);
-/* $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.
return cipher;
}
+LCRYPTO_ALIAS(EVP_CIPHER_meth_new);
EVP_CIPHER *
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)
return 1;
}
+LCRYPTO_ALIAS(EVP_CIPHER_meth_set_iv_length);
int
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)
return 1;
}
+LCRYPTO_ALIAS(EVP_CIPHER_meth_set_impl_ctx_size);
int
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,
return 1;
}
+LCRYPTO_ALIAS(EVP_CIPHER_meth_set_do_cipher);
int
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,
return 1;
}
+LCRYPTO_ALIAS(EVP_CIPHER_meth_set_set_asn1_params);
int
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,
return 1;
}
+LCRYPTO_ALIAS(EVP_CIPHER_meth_set_ctrl);
-/* $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.
*
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)
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
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
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)
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)
return 1;
}
+LCRYPTO_ALIAS(EVP_MD_CTX_copy_ex);
int
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)
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
return 1;
}
+LCRYPTO_ALIAS(EVP_MD_CTX_cleanup);
int
EVP_MD_CTX_ctrl(EVP_MD_CTX *ctx, int type, int arg, void *ptr)
}
return ret;
}
+LCRYPTO_ALIAS(EVP_MD_CTX_ctrl);
-/* $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.
*
return &aes_128_cbc;
#endif
}
+LCRYPTO_ALIAS(EVP_aes_128_cbc);
#ifdef AESNI_CAPABLE
static const EVP_CIPHER aesni_128_ecb = {
return &aes_128_ecb;
#endif
}
+LCRYPTO_ALIAS(EVP_aes_128_ecb);
#ifdef AESNI_CAPABLE
static const EVP_CIPHER aesni_128_ofb = {
return &aes_128_ofb;
#endif
}
+LCRYPTO_ALIAS(EVP_aes_128_ofb);
#ifdef AESNI_CAPABLE
static const EVP_CIPHER aesni_128_cfb = {
return &aes_128_cfb1;
#endif
}
+LCRYPTO_ALIAS(EVP_aes_128_cfb1);
#ifdef AESNI_CAPABLE
static const EVP_CIPHER aesni_128_cfb8 = {
return &aes_128_cfb8;
#endif
}
+LCRYPTO_ALIAS(EVP_aes_128_cfb8);
#ifdef AESNI_CAPABLE
static const EVP_CIPHER aesni_128_ctr = {
return &aes_128_ctr;
#endif
}
+LCRYPTO_ALIAS(EVP_aes_128_ctr);
#ifdef AESNI_CAPABLE
return &aes_192_cbc;
#endif
}
+LCRYPTO_ALIAS(EVP_aes_192_cbc);
#ifdef AESNI_CAPABLE
static const EVP_CIPHER aesni_192_ecb = {
return &aes_192_ecb;
#endif
}
+LCRYPTO_ALIAS(EVP_aes_192_ecb);
#ifdef AESNI_CAPABLE
static const EVP_CIPHER aesni_192_ofb = {
return &aes_192_ofb;
#endif
}
+LCRYPTO_ALIAS(EVP_aes_192_ofb);
#ifdef AESNI_CAPABLE
static const EVP_CIPHER aesni_192_cfb = {
return &aes_192_cfb1;
#endif
}
+LCRYPTO_ALIAS(EVP_aes_192_cfb1);
#ifdef AESNI_CAPABLE
static const EVP_CIPHER aesni_192_cfb8 = {
return &aes_192_cfb8;
#endif
}
+LCRYPTO_ALIAS(EVP_aes_192_cfb8);
#ifdef AESNI_CAPABLE
static const EVP_CIPHER aesni_192_ctr = {
return &aes_192_ctr;
#endif
}
+LCRYPTO_ALIAS(EVP_aes_192_ctr);
#ifdef AESNI_CAPABLE
return &aes_256_cbc;
#endif
}
+LCRYPTO_ALIAS(EVP_aes_256_cbc);
#ifdef AESNI_CAPABLE
static const EVP_CIPHER aesni_256_ecb = {
return &aes_256_ecb;
#endif
}
+LCRYPTO_ALIAS(EVP_aes_256_ecb);
#ifdef AESNI_CAPABLE
static const EVP_CIPHER aesni_256_ofb = {
return &aes_256_ofb;
#endif
}
+LCRYPTO_ALIAS(EVP_aes_256_ofb);
#ifdef AESNI_CAPABLE
static const EVP_CIPHER aesni_256_cfb = {
return &aes_256_cfb1;
#endif
}
+LCRYPTO_ALIAS(EVP_aes_256_cfb1);
#ifdef AESNI_CAPABLE
static const EVP_CIPHER aesni_256_cfb8 = {
return &aes_256_cfb8;
#endif
}
+LCRYPTO_ALIAS(EVP_aes_256_cfb8);
#ifdef AESNI_CAPABLE
static const EVP_CIPHER aesni_256_ctr = {
return &aes_256_ctr;
#endif
}
+LCRYPTO_ALIAS(EVP_aes_256_ctr);
static int
aes_gcm_cleanup(EVP_CIPHER_CTX *c)
return &aes_128_gcm;
#endif
}
+LCRYPTO_ALIAS(EVP_aes_128_gcm);
#ifdef AESNI_CAPABLE
static const EVP_CIPHER aesni_192_gcm = {
return &aes_192_gcm;
#endif
}
+LCRYPTO_ALIAS(EVP_aes_192_gcm);
#ifdef AESNI_CAPABLE
static const EVP_CIPHER aesni_256_gcm = {
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)
return &aes_128_xts;
#endif
}
+LCRYPTO_ALIAS(EVP_aes_128_xts);
#ifdef AESNI_CAPABLE
static const EVP_CIPHER aesni_256_xts = {
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)
return &aes_128_ccm;
#endif
}
+LCRYPTO_ALIAS(EVP_aes_128_ccm);
#ifdef AESNI_CAPABLE
static const EVP_CIPHER aesni_192_ccm = {
return &aes_192_ccm;
#endif
}
+LCRYPTO_ALIAS(EVP_aes_192_ccm);
#ifdef AESNI_CAPABLE
static const EVP_CIPHER aesni_256_ccm = {
return &aes_256_ccm;
#endif
}
+LCRYPTO_ALIAS(EVP_aes_256_ccm);
#define EVP_AEAD_AES_GCM_TAG_LEN 16
{
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 {
{
return &aes_128_wrap;
}
+LCRYPTO_ALIAS(EVP_aes_128_wrap);
static const EVP_CIPHER aes_192_wrap = {
.nid = NID_id_aes192_wrap,
{
return &aes_192_wrap;
}
+LCRYPTO_ALIAS(EVP_aes_192_wrap);
static const EVP_CIPHER aes_256_wrap = {
.nid = NID_id_aes256_wrap,
{
return &aes_256_wrap;
}
+LCRYPTO_ALIAS(EVP_aes_256_wrap);
#endif
-/* $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.
*
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)
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
-/* $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.
*
{
return &bf_cbc;
}
+LCRYPTO_ALIAS(EVP_bf_cbc);
static const EVP_CIPHER bf_cfb64 = {
.nid = NID_bf_cfb64,
{
return &bf_cfb64;
}
+LCRYPTO_ALIAS(EVP_bf_cfb64);
static const EVP_CIPHER bf_ofb = {
.nid = NID_bf_ofb64,
{
return &bf_ofb;
}
+LCRYPTO_ALIAS(EVP_bf_ofb);
static const EVP_CIPHER bf_ecb = {
.nid = NID_bf_ecb,
{
return &bf_ecb;
}
+LCRYPTO_ALIAS(EVP_bf_ecb);
#endif
-/* $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.
*
{
return &camellia_128_cbc;
}
+LCRYPTO_ALIAS(EVP_camellia_128_cbc);
static const EVP_CIPHER camellia_128_cfb128 = {
.nid = NID_camellia_128_cfb128,
{
return &camellia_128_cfb128;
}
+LCRYPTO_ALIAS(EVP_camellia_128_cfb128);
static const EVP_CIPHER camellia_128_ofb = {
.nid = NID_camellia_128_ofb128,
{
return &camellia_128_ofb;
}
+LCRYPTO_ALIAS(EVP_camellia_128_ofb);
static const EVP_CIPHER camellia_128_ecb = {
.nid = NID_camellia_128_ecb,
{
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)
{
return &camellia_192_cbc;
}
+LCRYPTO_ALIAS(EVP_camellia_192_cbc);
static const EVP_CIPHER camellia_192_cfb128 = {
.nid = NID_camellia_192_cfb128,
{
return &camellia_192_cfb128;
}
+LCRYPTO_ALIAS(EVP_camellia_192_cfb128);
static const EVP_CIPHER camellia_192_ofb = {
.nid = NID_camellia_192_ofb128,
{
return &camellia_192_ofb;
}
+LCRYPTO_ALIAS(EVP_camellia_192_ofb);
static const EVP_CIPHER camellia_192_ecb = {
.nid = NID_camellia_192_ecb,
{
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)
{
return &camellia_256_cbc;
}
+LCRYPTO_ALIAS(EVP_camellia_256_cbc);
static const EVP_CIPHER camellia_256_cfb128 = {
.nid = NID_camellia_256_cfb128,
{
return &camellia_256_cfb128;
}
+LCRYPTO_ALIAS(EVP_camellia_256_cfb128);
static const EVP_CIPHER camellia_256_ofb = {
.nid = NID_camellia_256_ofb128,
{
return &camellia_256_ofb;
}
+LCRYPTO_ALIAS(EVP_camellia_256_ofb);
static const EVP_CIPHER camellia_256_ecb = {
.nid = NID_camellia_256_ecb,
{
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)
{
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)
{
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)
{
return &camellia_256_cfb1;
}
+LCRYPTO_ALIAS(EVP_camellia_256_cfb1);
static int
{
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)
{
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)
{
return &camellia_256_cfb8;
}
+LCRYPTO_ALIAS(EVP_camellia_256_cfb8);
#endif
-/* $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.
*
{
return &cast5_cbc;
}
+LCRYPTO_ALIAS(EVP_cast5_cbc);
static const EVP_CIPHER cast5_cfb64 = {
.nid = NID_cast5_cfb64,
{
return &cast5_cfb64;
}
+LCRYPTO_ALIAS(EVP_cast5_cfb64);
static const EVP_CIPHER cast5_ofb = {
.nid = NID_cast5_ofb64,
{
return &cast5_ofb;
}
+LCRYPTO_ALIAS(EVP_cast5_ofb);
static const EVP_CIPHER cast5_ecb = {
.nid = NID_cast5_ecb,
{
return &cast5_ecb;
}
+LCRYPTO_ALIAS(EVP_cast5_ecb);
#endif
-/* $OpenBSD: e_chacha.c,v 1.10 2022/11/26 16:08:52 tb Exp $ */
+/* $OpenBSD: e_chacha.c,v 1.11 2023/07/07 13:54:45 beck Exp $ */
/*
* Copyright (c) 2014 Joel Sing <jsing@openbsd.org>
*
{
return (&chacha20_cipher);
}
+LCRYPTO_ALIAS(EVP_chacha20);
#endif
-/* $OpenBSD: e_chacha20poly1305.c,v 1.28 2023/03/01 11:16:06 tb Exp $ */
+/* $OpenBSD: e_chacha20poly1305.c,v 1.29 2023/07/07 13:54:45 beck Exp $ */
/*
* Copyright (c) 2022 Joel Sing <jsing@openbsd.org>
{
return &aead_chacha20_poly1305;
}
+LCRYPTO_ALIAS(EVP_aead_chacha20_poly1305);
static const EVP_AEAD aead_xchacha20_poly1305 = {
.key_len = 32,
{
return &aead_xchacha20_poly1305;
}
+LCRYPTO_ALIAS(EVP_aead_xchacha20_poly1305);
struct chacha20_poly1305_ctx {
ChaCha_ctx chacha;
{
return &cipher_chacha20_poly1305;
}
+LCRYPTO_ALIAS(EVP_chacha20_poly1305);
#endif /* !OPENSSL_NO_CHACHA && !OPENSSL_NO_POLY1305 */
-/* $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.
*
{
return &des_cbc;
}
+LCRYPTO_ALIAS(EVP_des_cbc);
static const EVP_CIPHER des_cfb64 = {
.nid = NID_des_cfb64,
{
return &des_cfb64;
}
+LCRYPTO_ALIAS(EVP_des_cfb64);
static const EVP_CIPHER des_ofb = {
.nid = NID_des_ofb64,
{
return &des_ofb;
}
+LCRYPTO_ALIAS(EVP_des_ofb);
static const EVP_CIPHER des_ecb = {
.nid = NID_des_ecb,
{
return &des_ecb;
}
+LCRYPTO_ALIAS(EVP_des_ecb);
static const EVP_CIPHER des_cfb1 = {
.nid = NID_des_cfb1,
{
return &des_cfb1;
}
+LCRYPTO_ALIAS(EVP_des_cfb1);
static const EVP_CIPHER des_cfb8 = {
.nid = NID_des_cfb8,
{
return &des_cfb8;
}
+LCRYPTO_ALIAS(EVP_des_cfb8);
#endif
-/* $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.
*
{
return &des_ede_cbc;
}
+LCRYPTO_ALIAS(EVP_des_ede_cbc);
static const EVP_CIPHER des_ede_cfb64 = {
.nid = NID_des_ede_cfb64,
{
return &des_ede_cfb64;
}
+LCRYPTO_ALIAS(EVP_des_ede_cfb64);
static const EVP_CIPHER des_ede_ofb = {
.nid = NID_des_ede_ofb64,
{
return &des_ede_ofb;
}
+LCRYPTO_ALIAS(EVP_des_ede_ofb);
static const EVP_CIPHER des_ede_ecb = {
.nid = NID_des_ede_ecb,
{
return &des_ede_ecb;
}
+LCRYPTO_ALIAS(EVP_des_ede_ecb);
#define des_ede3_cfb64_cipher des_ede_cfb64_cipher
{
return &des_ede3_cbc;
}
+LCRYPTO_ALIAS(EVP_des_ede3_cbc);
static const EVP_CIPHER des_ede3_cfb64 = {
.nid = NID_des_ede3_cfb64,
{
return &des_ede3_cfb64;
}
+LCRYPTO_ALIAS(EVP_des_ede3_cfb64);
static const EVP_CIPHER des_ede3_ofb = {
.nid = NID_des_ede3_ofb64,
{
return &des_ede3_ofb;
}
+LCRYPTO_ALIAS(EVP_des_ede3_ofb);
static const EVP_CIPHER des_ede3_ecb = {
.nid = NID_des_ede3_ecb,
{
return &des_ede3_ecb;
}
+LCRYPTO_ALIAS(EVP_des_ede3_ecb);
static const EVP_CIPHER des_ede3_cfb1 = {
{
return &des_ede3_cfb1;
}
+LCRYPTO_ALIAS(EVP_des_ede3_cfb1);
static const EVP_CIPHER des_ede3_cfb8 = {
{
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
-/* $OpenBSD: e_gost2814789.c,v 1.11 2022/11/26 16:08:52 tb Exp $ */
+/* $OpenBSD: e_gost2814789.c,v 1.12 2023/07/07 13:54:45 beck Exp $ */
/*
* Copyright (c) 2014 Dmitry Eremin-Solenikov <dbaryshkov@gmail.com>
* Copyright (c) 2005-2006 Cryptocom LTD
{
return &gost2814789_ecb;
}
+LCRYPTO_ALIAS(EVP_gost2814789_ecb);
static const EVP_CIPHER gost2814789_cfb64 = {
.nid = NID_gost89_cfb64,
{
return &gost2814789_cfb64;
}
+LCRYPTO_ALIAS(EVP_gost2814789_cfb64);
static const EVP_CIPHER gost2814789_cnt = {
.nid = NID_gost89_cnt,
{
return &gost2814789_cnt;
}
+LCRYPTO_ALIAS(EVP_gost2814789_cnt);
#endif
-/* $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.
*
{
return &idea_cbc;
}
+LCRYPTO_ALIAS(EVP_idea_cbc);
static const EVP_CIPHER idea_cfb64 = {
.nid = NID_idea_cfb64,
{
return &idea_cfb64;
}
+LCRYPTO_ALIAS(EVP_idea_cfb64);
static const EVP_CIPHER idea_ofb = {
.nid = NID_idea_ofb64,
{
return &idea_ofb;
}
+LCRYPTO_ALIAS(EVP_idea_ofb);
static const EVP_CIPHER idea_ecb = {
.nid = NID_idea_ecb,
{
return &idea_ecb;
}
+LCRYPTO_ALIAS(EVP_idea_ecb);
#endif
-/* $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.
*
{
return (&n_cipher);
}
+LCRYPTO_ALIAS(EVP_enc_null);
static int
null_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key,
-/* $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.
*
{
return &rc2_cbc;
}
+LCRYPTO_ALIAS(EVP_rc2_cbc);
static const EVP_CIPHER rc2_cfb64 = {
.nid = NID_rc2_cfb64,
{
return &rc2_cfb64;
}
+LCRYPTO_ALIAS(EVP_rc2_cfb64);
static const EVP_CIPHER rc2_ofb = {
.nid = NID_rc2_ofb64,
{
return &rc2_ofb;
}
+LCRYPTO_ALIAS(EVP_rc2_ofb);
static const EVP_CIPHER rc2_ecb = {
.nid = NID_rc2_ecb,
{
return &rc2_ecb;
}
+LCRYPTO_ALIAS(EVP_rc2_ecb);
#define RC2_40_MAGIC 0xa0
#define RC2_64_MAGIC 0x78
{
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,
-/* $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.
*
{
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,
-/* $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.
*
{
return (&r4_hmac_md5_cipher);
}
+LCRYPTO_ALIAS(EVP_rc4_hmac_md5);
#endif
-/* $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
*
{
return &sm4_cbc;
}
+LCRYPTO_ALIAS(EVP_sm4_cbc);
static const EVP_CIPHER sm4_cfb128 = {
.nid = NID_sm4_cfb128,
{
return &sm4_cfb128;
}
+LCRYPTO_ALIAS(EVP_sm4_cfb128);
static const EVP_CIPHER sm4_ofb = {
.nid = NID_sm4_ofb128,
{
return &sm4_ofb;
}
+LCRYPTO_ALIAS(EVP_sm4_ofb);
static const EVP_CIPHER sm4_ecb = {
.nid = NID_sm4_ecb,
{
return &sm4_ecb;
}
+LCRYPTO_ALIAS(EVP_sm4_ecb);
static int
sm4_ctr_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out, const unsigned char *in,
{
return &sm4_ctr_mode;
}
+LCRYPTO_ALIAS(EVP_sm4_ctr);
#endif
-/* $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.
*
{
return (&d_xcbc_cipher);
}
+LCRYPTO_ALIAS(EVP_desx_cbc);
static int
desx_cbc_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key,
-/* $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.
*
{
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)
ctx->num = 0;
ctx->line_num = 0;
}
+LCRYPTO_ALIAS(EVP_EncodeInit);
int
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)
}
*outl = ret;
}
+LCRYPTO_ALIAS(EVP_EncodeFinal);
int
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)
ctx->line_num = 0;
ctx->expect_nl = 0;
}
+LCRYPTO_ALIAS(EVP_DecodeInit);
int
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)
}
return (ret);
}
+LCRYPTO_ALIAS(EVP_DecodeBlock);
int
EVP_DecodeFinal(EVP_ENCODE_CTX *ctx, unsigned char *out, int *outl)
} else
return (1);
}
+LCRYPTO_ALIAS(EVP_DecodeFinal);
-/* $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.
*
{
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,
}
return aead->init(ctx, key, key_len, tag_len);
}
+LCRYPTO_ALIAS(EVP_AEAD_CTX_init);
void
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)
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.
*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,
*out_len = 0;
return 0;
}
+LCRYPTO_ALIAS(EVP_AEAD_CTX_open);
-/* $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.
*
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,
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,
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)
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");
ret = EVP_DecryptFinal_ex(ctx, out, outl);
return ret;
}
+LCRYPTO_ALIAS(EVP_CipherFinal);
int
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,
{
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,
{
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,
{
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,
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");
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)
return ret;
}
+LCRYPTO_ALIAS(EVP_EncryptFinal_ex);
int
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");
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)
*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)
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)
return 1;
}
+LCRYPTO_ALIAS(EVP_CIPHER_CTX_cleanup);
int
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)
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)
}
return ret;
}
+LCRYPTO_ALIAS(EVP_CIPHER_CTX_ctrl);
int
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)
return 1;
}
+LCRYPTO_ALIAS(EVP_CIPHER_CTX_copy);
-/* $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.
*
}
#endif
}
+LCRYPTO_ALIAS(ERR_load_EVP_strings);
-/* $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.
*
strlcpy(prompt_string, prompt, sizeof(prompt_string));
}
}
+LCRYPTO_ALIAS(EVP_set_pw_prompt);
char *
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,
explicit_bzero(buff, BUFSIZ);
return ret;
}
+LCRYPTO_ALIAS(EVP_read_pw_string_min);
int
EVP_BytesToKey(const EVP_CIPHER *type, const EVP_MD *md,
explicit_bzero(md_buf, sizeof md_buf);
return rv;
}
+LCRYPTO_ALIAS(EVP_BytesToKey);
-/* $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.
*
ret = -1;
return (ret);
}
+LCRYPTO_ALIAS(EVP_CIPHER_param_to_asn1);
int
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)
}
return (i);
}
+LCRYPTO_ALIAS(EVP_CIPHER_get_asn1_iv);
int
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
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,
{
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)
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)
}
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)
}
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)
}
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)
return md;
}
+LCRYPTO_ALIAS(EVP_MD_meth_new);
EVP_MD *
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)
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)
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)
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)
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))
md->init = init;
return 1;
}
+LCRYPTO_ALIAS(EVP_MD_meth_set_init);
int
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,
md->final = final;
return 1;
}
+LCRYPTO_ALIAS(EVP_MD_meth_set_final);
int
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,
md->cleanup = cleanup;
return 1;
}
+LCRYPTO_ALIAS(EVP_MD_meth_set_cleanup);
int
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)
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)
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);
-/* $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.
*/
}
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 *);
}
return 1;
}
+LCRYPTO_ALIAS(EVP_PBE_alg_add_type);
int
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,
*pkeygen = pbetmp->keygen;
return 1;
}
+LCRYPTO_ALIAS(EVP_PBE_find);
static void
free_evp_pbe_ctl(EVP_PBE_CTL *pbe)
sk_EVP_PBE_CTL_pop_free(pbe_algs, free_evp_pbe_ctl);
pbe_algs = NULL;
}
+LCRYPTO_ALIAS(EVP_PBE_cleanup);
-/* $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.
*/
EVP_PKEY_free(pkey);
return NULL;
}
+LCRYPTO_ALIAS(EVP_PKCS82PKEY);
/* Turn a private key into a PKCS8 structure */
PKCS8_PRIV_KEY_INFO_free(p8);
return NULL;
}
+LCRYPTO_ALIAS(EVP_PKEY2PKCS8);
/* EVP_PKEY attribute functions */
{
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,
{
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)
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,
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,
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,
return 1;
return 0;
}
+LCRYPTO_ALIAS(EVP_PKEY_add1_attr_by_txt);
-/* $OpenBSD: m_gost2814789.c,v 1.4 2022/11/26 16:08:52 tb Exp $ */
+/* $OpenBSD: m_gost2814789.c,v 1.5 2023/07/07 13:54:45 beck Exp $ */
/*
* Copyright (c) 2014 Dmitry Eremin-Solenikov <dbaryshkov@gmail.com>
* Copyright (c) 2005-2006 Cryptocom LTD
{
return (&gost2814789imit_md);
}
+LCRYPTO_ALIAS(EVP_gost2814789imit);
#endif
-/* $OpenBSD: m_gostr341194.c,v 1.5 2022/11/26 16:08:52 tb Exp $ */
+/* $OpenBSD: m_gostr341194.c,v 1.6 2023/07/07 13:54:45 beck Exp $ */
/*
* Copyright (c) 2014 Dmitry Eremin-Solenikov <dbaryshkov@gmail.com>
* Copyright (c) 2005-2006 Cryptocom LTD
{
return (&gostr341194_md);
}
+LCRYPTO_ALIAS(EVP_gostr341194);
#endif
-/* $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.
*
{
return (&md4_md);
}
+LCRYPTO_ALIAS(EVP_md4);
#endif
-/* $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.
*
{
return (&md5_md);
}
+LCRYPTO_ALIAS(EVP_md5);
#endif
-/* $OpenBSD: m_md5_sha1.c,v 1.5 2022/11/26 16:08:52 tb Exp $ */
+/* $OpenBSD: m_md5_sha1.c,v 1.6 2023/07/07 13:54:45 beck Exp $ */
/*
* Copyright (c) 2017 Joel Sing <jsing@openbsd.org>
*
{
return &md5_sha1_md;
}
+LCRYPTO_ALIAS(EVP_md5_sha1);
-/* $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.
*
{
return (&null_md);
}
+LCRYPTO_ALIAS(EVP_md_null);
-/* $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.
*
{
return (&ripemd160_md);
}
+LCRYPTO_ALIAS(EVP_ripemd160);
#endif
-/* $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.
*
{
return &sha1_md;
}
+LCRYPTO_ALIAS(EVP_sha1);
#endif
#ifndef OPENSSL_NO_SHA256
{
return &sha224_md;
}
+LCRYPTO_ALIAS(EVP_sha224);
static int
sha256_init(EVP_MD_CTX *ctx)
{
return &sha256_md;
}
+LCRYPTO_ALIAS(EVP_sha256);
#endif /* ifndef OPENSSL_NO_SHA256 */
#ifndef OPENSSL_NO_SHA512
{
return &sha384_md;
}
+LCRYPTO_ALIAS(EVP_sha384);
static int
sha512_init(EVP_MD_CTX *ctx)
{
return &sha512_md;
}
+LCRYPTO_ALIAS(EVP_sha512);
static int
sha512_224_init(EVP_MD_CTX *ctx)
{
return &sha512_224_md;
}
+LCRYPTO_ALIAS(EVP_sha512_224);
static int
sha512_256_init(EVP_MD_CTX *ctx)
{
return &sha512_256_md;
}
+LCRYPTO_ALIAS(EVP_sha512_256);
#endif /* ifndef OPENSSL_NO_SHA512 */
-/* $OpenBSD: m_sha3.c,v 1.1 2023/04/16 17:06:19 jsing Exp $ */
+/* $OpenBSD: m_sha3.c,v 1.2 2023/07/07 13:54:45 beck Exp $ */
/*
* Copyright (c) 2023 Joel Sing <jsing@openbsd.org>
*
{
return &sha3_224_md;
}
+LCRYPTO_ALIAS(EVP_sha3_224);
static int
sha3_256_init(EVP_MD_CTX *ctx)
{
return &sha3_256_md;
}
+LCRYPTO_ALIAS(EVP_sha3_256);
static int
sha3_384_init(EVP_MD_CTX *ctx)
{
return &sha3_384_md;
}
+LCRYPTO_ALIAS(EVP_sha3_384);
static int
sha3_512_init(EVP_MD_CTX *ctx)
{
return &sha3_512_md;
}
+LCRYPTO_ALIAS(EVP_sha3_512);
-/* $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.
*/
{
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,
{
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)
}
return 1;
}
+LCRYPTO_ALIAS(EVP_DigestSignFinal);
int
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)
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,
return EVP_DigestVerifyFinal(ctx, sigret, siglen);
}
+LCRYPTO_ALIAS(EVP_DigestVerify);
-/* $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
*
{
return &sm3_md;
}
+LCRYPTO_ALIAS(EVP_sm3);
#endif /* OPENSSL_NO_SM3 */
-/* $OpenBSD: m_streebog.c,v 1.5 2022/11/26 16:08:52 tb Exp $ */
+/* $OpenBSD: m_streebog.c,v 1.6 2023/07/07 13:54:46 beck Exp $ */
/*
* Copyright (c) 2014 Dmitry Eremin-Solenikov <dbaryshkov@gmail.com>
* Copyright (c) 2005-2006 Cryptocom LTD
{
return (&streebog256_md);
}
+LCRYPTO_ALIAS(EVP_streebog256);
const EVP_MD *
EVP_streebog512(void)
{
return (&streebog512_md);
}
+LCRYPTO_ALIAS(EVP_streebog512);
#endif
-/* $OpenBSD: m_wp.c,v 1.11 2022/11/26 16:08:52 tb Exp $ */
+/* $OpenBSD: m_wp.c,v 1.12 2023/07/07 13:54:46 beck Exp $ */
#include <stdio.h>
{
return (&whirlpool_md);
}
+LCRYPTO_ALIAS(EVP_whirlpool);
#endif
-/* $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.
*
(const char *)c);
return (r);
}
+LCRYPTO_ALIAS(EVP_add_cipher);
int
EVP_add_digest(const EVP_MD *md)
}
return (r);
}
+LCRYPTO_ALIAS(EVP_add_digest);
const EVP_CIPHER *
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)
cp = (const EVP_MD *)OBJ_NAME_get(name, OBJ_NAME_TYPE_MD_METH);
return (cp);
}
+LCRYPTO_ALIAS(EVP_get_digestbyname);
void
EVP_cleanup(void)
}
OBJ_sigid_free();
}
+LCRYPTO_ALIAS(EVP_cleanup);
struct doall_cipher {
void *arg;
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,
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;
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,
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);
-/* $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.
*/
PKCS5_PBE_add(void)
{
}
+LCRYPTO_ALIAS(PKCS5_PBE_add);
int
PKCS5_PBE_keyivgen(EVP_CIPHER_CTX *cctx, const char *pass, int passlen,
PBEPARAM_free(pbe);
return rv;
}
+LCRYPTO_ALIAS(PKCS5_PBE_keyivgen);
-/* $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.
*/
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,
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
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,
-/* $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.
*
#endif
return (ret);
}
+LCRYPTO_ALIAS(EVP_PKEY_decrypt_old);
-/* $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.
*
#endif
return (ret);
}
+LCRYPTO_ALIAS(EVP_PKEY_encrypt_old);
-/* $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.
*
return pkey->ameth->pkey_bits(pkey);
return 0;
}
+LCRYPTO_ALIAS(EVP_PKEY_bits);
int
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)
return pkey->ameth->pkey_size(pkey);
return 0;
}
+LCRYPTO_ALIAS(EVP_PKEY_size);
int
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)
err:
return 0;
}
+LCRYPTO_ALIAS(EVP_PKEY_copy_parameters);
int
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)
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)
return -2;
}
+LCRYPTO_ALIAS(EVP_PKEY_cmp);
EVP_PKEY *
EVP_PKEY_new(void)
ret->save_parameters = 1;
return (ret);
}
+LCRYPTO_ALIAS(EVP_PKEY_new);
int
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.
{
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,
return NULL;
}
+LCRYPTO_ALIAS(EVP_PKEY_new_raw_private_key);
EVP_PKEY *
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,
return 1;
}
+LCRYPTO_ALIAS(EVP_PKEY_get_raw_private_key);
int
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,
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)
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)
return os->data;
}
+LCRYPTO_ALIAS(EVP_PKEY_get0_hmac);
#ifndef OPENSSL_NO_RSA
RSA *
}
return pkey->pkey.rsa;
}
+LCRYPTO_ALIAS(EVP_PKEY_get0_RSA);
RSA *
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)
RSA_up_ref(key);
return ret;
}
+LCRYPTO_ALIAS(EVP_PKEY_set1_RSA);
#endif
#ifndef OPENSSL_NO_DSA
}
return pkey->pkey.dsa;
}
+LCRYPTO_ALIAS(EVP_PKEY_get0_DSA);
DSA *
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)
DSA_up_ref(key);
return ret;
}
+LCRYPTO_ALIAS(EVP_PKEY_set1_DSA);
#endif
#ifndef OPENSSL_NO_EC
}
return pkey->pkey.ec;
}
+LCRYPTO_ALIAS(EVP_PKEY_get0_EC_KEY);
EC_KEY *
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)
EC_KEY_up_ref(key);
return ret;
}
+LCRYPTO_ALIAS(EVP_PKEY_set1_EC_KEY);
#endif
}
return pkey->pkey.dh;
}
+LCRYPTO_ALIAS(EVP_PKEY_get0_DH);
DH *
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)
DH_up_ref(key);
return ret;
}
+LCRYPTO_ALIAS(EVP_PKEY_set1_DH);
#endif
int
#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)
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)
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,
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,
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)
return pkey->ameth->pkey_ctrl(pkey, ASN1_PKEY_CTRL_DEFAULT_MD_NID,
0, pnid);
}
+LCRYPTO_ALIAS(EVP_PKEY_get_default_digest_nid);
-/* $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.
*
freezero(key, size);
return (ret);
}
+LCRYPTO_ALIAS(EVP_OpenInit);
int
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
-/* $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.
*
}
return (npubk);
}
+LCRYPTO_ALIAS(EVP_SealInit);
/* MACRO
void EVP_SealUpdate(ctx,out,outl,in,inl)
i = EVP_EncryptInit_ex(ctx, NULL, NULL, NULL, NULL);
return i;
}
+LCRYPTO_ALIAS(EVP_SealFinal);
-/* $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.
*
EVP_PKEY_CTX_free(pkctx);
return ret;
}
+LCRYPTO_ALIAS(EVP_SignFinal);
-/* $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.
*
EVP_PKEY_CTX_free(pkctx);
return ret;
}
+LCRYPTO_ALIAS(EVP_VerifyFinal);
-/* $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.
*/
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,
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)
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,
}
return ctx->pmeth->verify(ctx, sig, siglen, tbs, tbslen);
}
+LCRYPTO_ALIAS(EVP_PKEY_verify);
int
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,
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)
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,
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)
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,
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)
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)
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)
M_check_autoarg(ctx, key, pkeylen, EVP_F_EVP_PKEY_DERIVE)
return ctx->pmeth->derive(ctx, key, pkeylen);
}
+LCRYPTO_ALIAS(EVP_PKEY_derive);
-/* $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.
*/
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)
}
return ret;
}
+LCRYPTO_ALIAS(EVP_PKEY_paramgen);
int
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)
}
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.
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)
EVP_PKEY_CTX_free(mac_ctx);
return mac_key;
}
+LCRYPTO_ALIAS(EVP_PKEY_new_mac_key);
int
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)
return pkey->ameth->pkey_public_check(pkey);
}
+LCRYPTO_ALIAS(EVP_PKEY_public_check);
int
EVP_PKEY_param_check(EVP_PKEY_CTX *ctx)
return pkey->ameth->pkey_param_check(pkey);
}
+LCRYPTO_ALIAS(EVP_PKEY_param_check);
-/* $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.
*/
return NULL;
}
+LCRYPTO_ALIAS(EVP_PKEY_meth_find);
static EVP_PKEY_CTX *
evp_pkey_ctx_new(EVP_PKEY *pkey, ENGINE *engine, int id)
return pmeth;
}
+LCRYPTO_ALIAS(EVP_PKEY_meth_new);
void
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)
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)
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)
EVP_PKEY_CTX_free(rctx);
return NULL;
}
+LCRYPTO_ALIAS(EVP_PKEY_CTX_dup);
int
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)
#endif
free(ctx);
}
+LCRYPTO_ALIAS(EVP_PKEY_CTX_free);
int
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)
}
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)
{
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)
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,
{
pmeth->init = init;
}
+LCRYPTO_ALIAS(EVP_PKEY_meth_set_init);
void
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,
{
pmeth->cleanup = cleanup;
}
+LCRYPTO_ALIAS(EVP_PKEY_meth_set_cleanup);
void
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
{
pmeth->public_check = public_check;
}
+LCRYPTO_ALIAS(EVP_PKEY_meth_set_public_check);
void
EVP_PKEY_meth_set_param_check(EVP_PKEY_METHOD *pmeth,
{
pmeth->param_check = param_check;
}
+LCRYPTO_ALIAS(EVP_PKEY_meth_set_param_check);
-/* $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
return 1;
}
+LCRYPTO_ALIAS(HKDF);
/* https://tools.ietf.org/html/rfc5869#section-2.2 */
int
*out_len = len;
return 1;
}
+LCRYPTO_ALIAS(HKDF_extract);
/* https://tools.ietf.org/html/rfc5869#section-2.3 */
int
CRYPTOerror(ERR_R_CRYPTO_LIB);
return ret;
}
+LCRYPTO_ALIAS(HKDF_expand);
projects / openbsd / commitdiff