me aliasing symbols not in the headers I was procesing.
This unbreaks the namespace build so it will pass again
ok tb@
_libre_ASN1_UTCTIME_set
_libre_ASN1_UTCTIME_adj
_libre_ASN1_UTCTIME_set_string
-_libre_ASN1_UTCTIME_cmp_time_t
_libre_ASN1_GENERALIZEDTIME_check
_libre_ASN1_GENERALIZEDTIME_set
_libre_ASN1_GENERALIZEDTIME_adj
_libre_ASN1_put_eoc
_libre_ASN1_object_size
_libre_ASN1_item_dup
-_libre_ASN1_dup
_libre_ASN1_d2i_fp
_libre_ASN1_item_d2i_fp
_libre_ASN1_i2d_fp
_libre_ERR_load_ASN1_strings
_libre_ASN1_time_parse
_libre_ASN1_time_tm_cmp
-_libre_ASN1_item_ex_new
-_libre_ASN1_item_ex_free
-_libre_ASN1_template_new
-_libre_ASN1_primitive_new
-_libre_ASN1_template_free
-_libre_ASN1_template_d2i
-_libre_ASN1_item_ex_d2i
-_libre_ASN1_item_ex_i2d
-_libre_ASN1_template_i2d
-_libre_ASN1_primitive_free
_libre_BIO_set_flags
_libre_BIO_test_flags
_libre_BIO_clear_flags
_libre_BIO_snprintf
_libre_BIO_vsnprintf
_libre_ERR_load_BIO_strings
-_libre_SM4_set_key
-_libre_SM4_decrypt
-_libre_SM4_encrypt
-_libre_SM3_Init
-_libre_SM3_Update
-_libre_SM3_Final
+_libre_ASN1_item_ex_new
+_libre_ASN1_item_ex_free
+_libre_ASN1_template_new
+_libre_ASN1_primitive_new
+_libre_ASN1_template_free
+_libre_ASN1_template_d2i
+_libre_ASN1_item_ex_d2i
+_libre_ASN1_item_ex_i2d
+_libre_ASN1_template_i2d
+_libre_ASN1_primitive_free
+_libre_EC_GFp_simple_method
+_libre_EC_GFp_mont_method
+_libre_EC_GROUP_new
+_libre_EC_GROUP_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_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_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_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_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_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_RAND_set_rand_method
_libre_RAND_get_rand_method
_libre_RAND_set_rand_engine
_libre_RAND_SSLeay
-_libre_RAND_cleanup
-_libre_RAND_bytes
-_libre_RAND_pseudo_bytes
-_libre_RAND_seed
-_libre_RAND_add
-_libre_RAND_load_file
-_libre_RAND_write_file
-_libre_RAND_file_name
-_libre_RAND_status
-_libre_RAND_poll
_libre_ERR_load_RAND_strings
-_libre_CRYPTO_poly1305_init
-_libre_CRYPTO_poly1305_update
-_libre_CRYPTO_poly1305_finish
+_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_HKDF
+_libre_HKDF_extract
+_libre_HKDF_expand
_libre_TS_REQ_new
_libre_TS_REQ_free
_libre_i2d_TS_REQ
_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_SM4_set_key
+_libre_SM4_decrypt
+_libre_SM4_encrypt
+_libre_CRYPTO_poly1305_init
+_libre_CRYPTO_poly1305_update
+_libre_CRYPTO_poly1305_finish
_libre_ECDH_OpenSSL
_libre_ECDH_set_default_method
_libre_ECDH_get_default_method
_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
-_libre_RC2_decrypt
-_libre_RC2_cbc_encrypt
-_libre_RC2_cfb64_encrypt
-_libre_RC2_ofb64_encrypt
_libre_PEM_get_EVP_CIPHER_INFO
_libre_PEM_do_header
_libre_PEM_read_bio
-/* $OpenBSD: a_pkey.c,v 1.5 2023/07/05 21:23:36 beck Exp $ */
+/* $OpenBSD: a_pkey.c,v 1.6 2023/07/07 19:37:52 beck Exp $ */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
* All rights reserved.
*
EVP_PKEY_free(ret);
return (NULL);
}
-LCRYPTO_ALIAS(d2i_PrivateKey);
int
i2d_PrivateKey(EVP_PKEY *a, unsigned char **pp)
ASN1error(ASN1_R_UNSUPPORTED_PUBLIC_KEY_TYPE);
return (-1);
}
-LCRYPTO_ALIAS(i2d_PrivateKey);
/* This works like d2i_PrivateKey() except it automatically works out the type */
sk_ASN1_TYPE_pop_free(inkey, ASN1_TYPE_free);
return d2i_PrivateKey(keytype, a, pp, length);
}
-LCRYPTO_ALIAS(d2i_AutoPrivateKey);
-/* $OpenBSD: a_pubkey.c,v 1.5 2023/07/05 21:23:36 beck Exp $ */
+/* $OpenBSD: a_pubkey.c,v 1.6 2023/07/07 19:37:52 beck Exp $ */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
* All rights reserved.
*
EVP_PKEY_free(ret);
return (NULL);
}
-LCRYPTO_ALIAS(d2i_PublicKey);
int
i2d_PublicKey(EVP_PKEY *a, unsigned char **pp)
return (-1);
}
}
-LCRYPTO_ALIAS(i2d_PublicKey);
-/* $OpenBSD: a_strex.c,v 1.33 2023/07/05 21:23:36 beck Exp $ */
+/* $OpenBSD: a_strex.c,v 1.34 2023/07/07 19:37:52 beck Exp $ */
/* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
* project 2000.
*/
return X509_NAME_print(out, nm, indent);
return do_name_ex(send_bio_chars, out, nm, indent, flags);
}
-LCRYPTO_ALIAS(X509_NAME_print_ex);
int
X509_NAME_print_ex_fp(FILE *fp, const X509_NAME *nm, int indent,
}
return do_name_ex(send_fp_chars, fp, nm, indent, flags);
}
-LCRYPTO_ALIAS(X509_NAME_print_ex_fp);
int
ASN1_STRING_print_ex(BIO *out, const ASN1_STRING *str, unsigned long flags)
-/* $OpenBSD: a_time_tm.c,v 1.28 2023/07/05 21:23:36 beck Exp $ */
+/* $OpenBSD: a_time_tm.c,v 1.29 2023/07/07 19:37:52 beck Exp $ */
/*
* Copyright (c) 2015 Bob Beck <beck@openbsd.org>
*
#endif
return 1;
}
-LCRYPTO_ALIAS(ASN1_time_tm_clamp_notafter);
/* Convert time to GeneralizedTime, X.690, 11.7. */
ASN1_TIME *
return ASN1_TIME_cmp_time_t_internal(s, t, V_ASN1_UTCTIME);
return -2;
}
-LCRYPTO_ALIAS(ASN1_UTCTIME_cmp_time_t);
/*
* ASN1_GENERALIZEDTIME wrappers
-/* $OpenBSD: ameth_lib.c,v 1.31 2023/07/05 21:23:36 beck Exp $ */
+/* $OpenBSD: ameth_lib.c,v 1.32 2023/07/07 19:37:52 beck Exp $ */
/* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
* project 2006.
*/
return num;
}
-LCRYPTO_ALIAS(EVP_PKEY_asn1_get_count);
const EVP_PKEY_ASN1_METHOD *
EVP_PKEY_asn1_get0(int idx)
return sk_EVP_PKEY_ASN1_METHOD_value(asn1_app_methods, idx);
}
-LCRYPTO_ALIAS(EVP_PKEY_asn1_get0);
static const EVP_PKEY_ASN1_METHOD *
pkey_asn1_find(int pkey_id)
}
return mp;
}
-LCRYPTO_ALIAS(EVP_PKEY_asn1_find);
const EVP_PKEY_ASN1_METHOD *
EVP_PKEY_asn1_find_str(ENGINE **pe, const char *str, int len)
}
return NULL;
}
-LCRYPTO_ALIAS(EVP_PKEY_asn1_find_str);
int
EVP_PKEY_asn1_add0(const EVP_PKEY_ASN1_METHOD *ameth)
return 1;
}
-LCRYPTO_ALIAS(EVP_PKEY_asn1_add0);
int
EVP_PKEY_asn1_add_alias(int to, int from)
}
return 1;
}
-LCRYPTO_ALIAS(EVP_PKEY_asn1_add_alias);
int
EVP_PKEY_asn1_get0_info(int *ppkey_id, int *ppkey_base_id, int *ppkey_flags,
*ppem_str = ameth->pem_str;
return 1;
}
-LCRYPTO_ALIAS(EVP_PKEY_asn1_get0_info);
const EVP_PKEY_ASN1_METHOD*
EVP_PKEY_get0_asn1(const EVP_PKEY *pkey)
{
return pkey->ameth;
}
-LCRYPTO_ALIAS(EVP_PKEY_get0_asn1);
EVP_PKEY_ASN1_METHOD*
EVP_PKEY_asn1_new(int id, int flags, const char *pem_str, const char *info)
EVP_PKEY_asn1_free(ameth);
return NULL;
}
-LCRYPTO_ALIAS(EVP_PKEY_asn1_new);
void
EVP_PKEY_asn1_copy(EVP_PKEY_ASN1_METHOD *dst, const EVP_PKEY_ASN1_METHOD *src)
dst->pem_str = preserve.pem_str;
dst->info = preserve.info;
}
-LCRYPTO_ALIAS(EVP_PKEY_asn1_copy);
void
EVP_PKEY_asn1_free(EVP_PKEY_ASN1_METHOD *ameth)
free(ameth);
}
}
-LCRYPTO_ALIAS(EVP_PKEY_asn1_free);
void
EVP_PKEY_asn1_set_public(EVP_PKEY_ASN1_METHOD *ameth,
ameth->pkey_size = pkey_size;
ameth->pkey_bits = pkey_bits;
}
-LCRYPTO_ALIAS(EVP_PKEY_asn1_set_public);
void
EVP_PKEY_asn1_set_private(EVP_PKEY_ASN1_METHOD *ameth,
ameth->priv_encode = priv_encode;
ameth->priv_print = priv_print;
}
-LCRYPTO_ALIAS(EVP_PKEY_asn1_set_private);
void
EVP_PKEY_asn1_set_param(EVP_PKEY_ASN1_METHOD *ameth,
ameth->param_cmp = param_cmp;
ameth->param_print = param_print;
}
-LCRYPTO_ALIAS(EVP_PKEY_asn1_set_param);
void
EVP_PKEY_asn1_set_free(EVP_PKEY_ASN1_METHOD *ameth,
{
ameth->pkey_free = pkey_free;
}
-LCRYPTO_ALIAS(EVP_PKEY_asn1_set_free);
void
EVP_PKEY_asn1_set_ctrl(EVP_PKEY_ASN1_METHOD *ameth,
{
ameth->pkey_ctrl = pkey_ctrl;
}
-LCRYPTO_ALIAS(EVP_PKEY_asn1_set_ctrl);
void
EVP_PKEY_asn1_set_security_bits(EVP_PKEY_ASN1_METHOD *ameth,
{
ameth->pkey_security_bits = pkey_security_bits;
}
-LCRYPTO_ALIAS(EVP_PKEY_asn1_set_security_bits);
void
EVP_PKEY_asn1_set_check(EVP_PKEY_ASN1_METHOD *ameth,
{
ameth->pkey_check = pkey_check;
}
-LCRYPTO_ALIAS(EVP_PKEY_asn1_set_check);
void
EVP_PKEY_asn1_set_public_check(EVP_PKEY_ASN1_METHOD *ameth,
{
ameth->pkey_public_check = pkey_public_check;
}
-LCRYPTO_ALIAS(EVP_PKEY_asn1_set_public_check);
void
EVP_PKEY_asn1_set_param_check(EVP_PKEY_ASN1_METHOD *ameth,
{
ameth->pkey_param_check = pkey_param_check;
}
-LCRYPTO_ALIAS(EVP_PKEY_asn1_set_param_check);
-/* $OpenBSD: asn1_item.c,v 1.15 2023/07/05 21:23:36 beck Exp $ */
+/* $OpenBSD: asn1_item.c,v 1.16 2023/07/07 19:37:52 beck Exp $ */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
* All rights reserved.
*
free(str);
return (1);
}
-LCRYPTO_ALIAS(ASN1_item_digest);
/*
* ASN1_ITEM version of ASN1_dup(): follows the same model except there's no
}
return ASN1_item_sign_ctx(it, algor1, algor2, signature, asn, &ctx);
}
-LCRYPTO_ALIAS(ASN1_item_sign);
int
ASN1_item_sign_ctx(const ASN1_ITEM *it, X509_ALGOR *algor1, X509_ALGOR *algor2,
return ret;
}
-LCRYPTO_ALIAS(ASN1_item_sign_ctx);
int
ASN1_item_verify(const ASN1_ITEM *it, X509_ALGOR *a,
return ret;
}
-LCRYPTO_ALIAS(ASN1_item_verify);
#define HEADER_SIZE 8
#define ASN1_CHUNK_INITIAL_SIZE (16 * 1024)
-/* $OpenBSD: asn1_old.c,v 1.4 2023/07/05 21:23:36 beck Exp $ */
+/* $OpenBSD: asn1_old.c,v 1.5 2023/07/07 19:37:52 beck Exp $ */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
* All rights reserved.
*
free(b);
return (ret);
}
-LCRYPTO_ALIAS(ASN1_dup);
void *
ASN1_d2i_fp(void *(*xnew)(void), d2i_of_void *d2i, FILE *in, void **x)
-/* $OpenBSD: p5_pbe.c,v 1.24 2023/07/05 21:23:36 beck Exp $ */
+/* $OpenBSD: p5_pbe.c,v 1.25 2023/07/07 19:37:52 beck Exp $ */
/* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
* project 1999.
*/
return (PBEPARAM *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&PBEPARAM_it);
}
-LCRYPTO_ALIAS(d2i_PBEPARAM);
int
i2d_PBEPARAM(PBEPARAM *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &PBEPARAM_it);
}
-LCRYPTO_ALIAS(i2d_PBEPARAM);
PBEPARAM *
PBEPARAM_new(void)
{
return (PBEPARAM *)ASN1_item_new(&PBEPARAM_it);
}
-LCRYPTO_ALIAS(PBEPARAM_new);
void
PBEPARAM_free(PBEPARAM *a)
{
ASN1_item_free((ASN1_VALUE *)a, &PBEPARAM_it);
}
-LCRYPTO_ALIAS(PBEPARAM_free);
/* Set an algorithm identifier for a PKCS#5 PBE algorithm */
ASN1_STRING_free(pbe_str);
return 0;
}
-LCRYPTO_ALIAS(PKCS5_pbe_set0_algor);
/* Return an algorithm identifier for a PKCS#5 PBE algorithm */
X509_ALGOR_free(ret);
return NULL;
}
-LCRYPTO_ALIAS(PKCS5_pbe_set);
-/* $OpenBSD: p5_pbev2.c,v 1.29 2023/07/05 21:23:36 beck Exp $ */
+/* $OpenBSD: p5_pbev2.c,v 1.30 2023/07/07 19:37:52 beck Exp $ */
/* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
* project 1999-2004.
*/
return (PBE2PARAM *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&PBE2PARAM_it);
}
-LCRYPTO_ALIAS(d2i_PBE2PARAM);
int
i2d_PBE2PARAM(PBE2PARAM *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &PBE2PARAM_it);
}
-LCRYPTO_ALIAS(i2d_PBE2PARAM);
PBE2PARAM *
PBE2PARAM_new(void)
{
return (PBE2PARAM *)ASN1_item_new(&PBE2PARAM_it);
}
-LCRYPTO_ALIAS(PBE2PARAM_new);
void
PBE2PARAM_free(PBE2PARAM *a)
{
ASN1_item_free((ASN1_VALUE *)a, &PBE2PARAM_it);
}
-LCRYPTO_ALIAS(PBE2PARAM_free);
static const ASN1_TEMPLATE PBKDF2PARAM_seq_tt[] = {
{
return (PBKDF2PARAM *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&PBKDF2PARAM_it);
}
-LCRYPTO_ALIAS(d2i_PBKDF2PARAM);
int
i2d_PBKDF2PARAM(PBKDF2PARAM *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &PBKDF2PARAM_it);
}
-LCRYPTO_ALIAS(i2d_PBKDF2PARAM);
PBKDF2PARAM *
PBKDF2PARAM_new(void)
{
return (PBKDF2PARAM *)ASN1_item_new(&PBKDF2PARAM_it);
}
-LCRYPTO_ALIAS(PBKDF2PARAM_new);
void
PBKDF2PARAM_free(PBKDF2PARAM *a)
{
ASN1_item_free((ASN1_VALUE *)a, &PBKDF2PARAM_it);
}
-LCRYPTO_ALIAS(PBKDF2PARAM_free);
/* Return an algorithm identifier for a PKCS#5 v2.0 PBE algorithm:
* yes I know this is horrible!
return NULL;
}
-LCRYPTO_ALIAS(PKCS5_pbe2_set_iv);
X509_ALGOR *
PKCS5_pbe2_set(const EVP_CIPHER *cipher, int iter, unsigned char *salt,
{
return PKCS5_pbe2_set_iv(cipher, iter, salt, saltlen, NULL, -1);
}
-LCRYPTO_ALIAS(PKCS5_pbe2_set);
X509_ALGOR *
PKCS5_pbkdf2_set(int iter, unsigned char *salt, int saltlen, int prf_nid,
X509_ALGOR_free(keyfunc);
return NULL;
}
-LCRYPTO_ALIAS(PKCS5_pbkdf2_set);
-/* $OpenBSD: p8_pkey.c,v 1.22 2023/07/05 21:23:36 beck Exp $ */
+/* $OpenBSD: p8_pkey.c,v 1.23 2023/07/07 19:37:52 beck Exp $ */
/* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
* project 1999.
*/
return (PKCS8_PRIV_KEY_INFO *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&PKCS8_PRIV_KEY_INFO_it);
}
-LCRYPTO_ALIAS(d2i_PKCS8_PRIV_KEY_INFO);
int
i2d_PKCS8_PRIV_KEY_INFO(PKCS8_PRIV_KEY_INFO *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &PKCS8_PRIV_KEY_INFO_it);
}
-LCRYPTO_ALIAS(i2d_PKCS8_PRIV_KEY_INFO);
PKCS8_PRIV_KEY_INFO *
PKCS8_PRIV_KEY_INFO_new(void)
{
return (PKCS8_PRIV_KEY_INFO *)ASN1_item_new(&PKCS8_PRIV_KEY_INFO_it);
}
-LCRYPTO_ALIAS(PKCS8_PRIV_KEY_INFO_new);
void
PKCS8_PRIV_KEY_INFO_free(PKCS8_PRIV_KEY_INFO *a)
{
ASN1_item_free((ASN1_VALUE *)a, &PKCS8_PRIV_KEY_INFO_it);
}
-LCRYPTO_ALIAS(PKCS8_PRIV_KEY_INFO_free);
int
PKCS8_pkey_set0(PKCS8_PRIV_KEY_INFO *priv, ASN1_OBJECT *aobj, int version,
ASN1_STRING_set0(priv->pkey, penc, penclen);
return 1;
}
-LCRYPTO_ALIAS(PKCS8_pkey_set0);
int
PKCS8_pkey_get0(const ASN1_OBJECT **ppkalg, const unsigned char **pk,
*pa = p8->pkeyalg;
return 1;
}
-LCRYPTO_ALIAS(PKCS8_pkey_get0);
const STACK_OF(X509_ATTRIBUTE) *
PKCS8_pkey_get0_attrs(const PKCS8_PRIV_KEY_INFO *p8)
{
return p8->attributes;
}
-LCRYPTO_ALIAS(PKCS8_pkey_get0_attrs);
int
PKCS8_pkey_add1_attr_by_NID(PKCS8_PRIV_KEY_INFO *p8, int nid, int type,
return 1;
return 0;
}
-LCRYPTO_ALIAS(PKCS8_pkey_add1_attr_by_NID);
-/* $OpenBSD: t_crl.c,v 1.22 2023/07/05 21:23:36 beck Exp $ */
+/* $OpenBSD: t_crl.c,v 1.23 2023/07/07 19:37:52 beck Exp $ */
/* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
* project 1999.
*/
BIO_free(b);
return (ret);
}
-LCRYPTO_ALIAS(X509_CRL_print_fp);
int
X509_CRL_print(BIO *out, X509_CRL *x)
err:
return 0;
}
-LCRYPTO_ALIAS(X509_CRL_print);
-/* $OpenBSD: t_req.c,v 1.25 2023/07/05 21:23:36 beck Exp $ */
+/* $OpenBSD: t_req.c,v 1.26 2023/07/07 19:37:52 beck Exp $ */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
* All rights reserved.
*
BIO_free(b);
return (ret);
}
-LCRYPTO_ALIAS(X509_REQ_print_fp);
int
X509_REQ_print_ex(BIO *bp, X509_REQ *x, unsigned long nmflags,
X509error(ERR_R_BUF_LIB);
return (0);
}
-LCRYPTO_ALIAS(X509_REQ_print_ex);
int
X509_REQ_print(BIO *bp, X509_REQ *x)
{
return X509_REQ_print_ex(bp, x, XN_FLAG_COMPAT, X509_FLAG_COMPAT);
}
-LCRYPTO_ALIAS(X509_REQ_print);
-/* $OpenBSD: t_spki.c,v 1.15 2023/07/05 21:23:36 beck Exp $ */
+/* $OpenBSD: t_spki.c,v 1.16 2023/07/07 19:37:52 beck Exp $ */
/* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
* project 1999.
*/
BIO_write(out, "\n", 1);
return 1;
}
-LCRYPTO_ALIAS(NETSCAPE_SPKI_print);
-/* $OpenBSD: t_x509.c,v 1.42 2023/07/05 21:23:36 beck Exp $ */
+/* $OpenBSD: t_x509.c,v 1.43 2023/07/07 19:37:52 beck Exp $ */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
* All rights reserved.
*
{
return X509_print_ex_fp(fp, x, XN_FLAG_COMPAT, X509_FLAG_COMPAT);
}
-LCRYPTO_ALIAS(X509_print_fp);
int
X509_print_ex_fp(FILE *fp, X509 *x, unsigned long nmflag, unsigned long cflag)
BIO_free(b);
return (ret);
}
-LCRYPTO_ALIAS(X509_print_ex_fp);
int
X509_print(BIO *bp, X509 *x)
{
return X509_print_ex(bp, x, XN_FLAG_COMPAT, X509_FLAG_COMPAT);
}
-LCRYPTO_ALIAS(X509_print);
int
X509_print_ex(BIO *bp, X509 *x, unsigned long nmflags, unsigned long cflag)
free(m);
return (ret);
}
-LCRYPTO_ALIAS(X509_print_ex);
int
X509_ocspid_print(BIO *bp, X509 *x)
free(der);
return (0);
}
-LCRYPTO_ALIAS(X509_ocspid_print);
int
X509_signature_dump(BIO *bp, const ASN1_STRING *sig, int indent)
return 1;
}
-LCRYPTO_ALIAS(X509_signature_dump);
int
X509_signature_print(BIO *bp, const X509_ALGOR *sigalg, const ASN1_STRING *sig)
return 0;
return 1;
}
-LCRYPTO_ALIAS(X509_signature_print);
int
ASN1_TIME_print(BIO *bp, const ASN1_TIME *tm)
free(b);
return (ret);
}
-LCRYPTO_ALIAS(X509_NAME_print);
-/* $OpenBSD: t_x509a.c,v 1.12 2023/07/05 21:23:36 beck Exp $ */
+/* $OpenBSD: t_x509a.c,v 1.13 2023/07/07 19:37:52 beck Exp $ */
/* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
* project 1999.
*/
}
return 1;
}
-LCRYPTO_ALIAS(X509_CERT_AUX_print);
-/* $OpenBSD: x_algor.c,v 1.24 2023/07/05 21:23:37 beck Exp $ */
+/* $OpenBSD: x_algor.c,v 1.25 2023/07/07 19:37:52 beck Exp $ */
/* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
* project 2000.
*/
return (X509_ALGOR *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&X509_ALGOR_it);
}
-LCRYPTO_ALIAS(d2i_X509_ALGOR);
int
i2d_X509_ALGOR(X509_ALGOR *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &X509_ALGOR_it);
}
-LCRYPTO_ALIAS(i2d_X509_ALGOR);
X509_ALGOR *
X509_ALGOR_new(void)
{
return (X509_ALGOR *)ASN1_item_new(&X509_ALGOR_it);
}
-LCRYPTO_ALIAS(X509_ALGOR_new);
void
X509_ALGOR_free(X509_ALGOR *a)
{
ASN1_item_free((ASN1_VALUE *)a, &X509_ALGOR_it);
}
-LCRYPTO_ALIAS(X509_ALGOR_free);
X509_ALGORS *
d2i_X509_ALGORS(X509_ALGORS **a, const unsigned char **in, long len)
return (X509_ALGORS *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&X509_ALGORS_it);
}
-LCRYPTO_ALIAS(d2i_X509_ALGORS);
int
i2d_X509_ALGORS(X509_ALGORS *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &X509_ALGORS_it);
}
-LCRYPTO_ALIAS(i2d_X509_ALGORS);
X509_ALGOR *
X509_ALGOR_dup(X509_ALGOR *x)
{
return ASN1_item_dup(&X509_ALGOR_it, x);
}
-LCRYPTO_ALIAS(X509_ALGOR_dup);
int
X509_ALGOR_set0(X509_ALGOR *alg, ASN1_OBJECT *aobj, int ptype, void *pval)
ASN1_TYPE_set(alg->parameter, ptype, pval);
return 1;
}
-LCRYPTO_ALIAS(X509_ALGOR_set0);
void
X509_ALGOR_get0(const ASN1_OBJECT **paobj, int *pptype, const void **ppval,
*ppval = algor->parameter->value.ptr;
}
}
-LCRYPTO_ALIAS(X509_ALGOR_get0);
/* Set up an X509_ALGOR DigestAlgorithmIdentifier from an EVP_MD */
X509_ALGOR_set0(alg, OBJ_nid2obj(EVP_MD_type(md)), param_type, NULL);
}
-LCRYPTO_ALIAS(X509_ALGOR_set_md);
/* Returns 0 if they are equal, != 0 otherwise. */
int
}
return(rv);
}
-LCRYPTO_ALIAS(X509_ALGOR_cmp);
-/* $OpenBSD: x_attrib.c,v 1.19 2023/07/05 21:23:37 beck Exp $ */
+/* $OpenBSD: x_attrib.c,v 1.20 2023/07/07 19:37:52 beck Exp $ */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
* All rights reserved.
*
return (X509_ATTRIBUTE *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&X509_ATTRIBUTE_it);
}
-LCRYPTO_ALIAS(d2i_X509_ATTRIBUTE);
int
i2d_X509_ATTRIBUTE(X509_ATTRIBUTE *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &X509_ATTRIBUTE_it);
}
-LCRYPTO_ALIAS(i2d_X509_ATTRIBUTE);
X509_ATTRIBUTE *
X509_ATTRIBUTE_new(void)
{
return (X509_ATTRIBUTE *)ASN1_item_new(&X509_ATTRIBUTE_it);
}
-LCRYPTO_ALIAS(X509_ATTRIBUTE_new);
void
X509_ATTRIBUTE_free(X509_ATTRIBUTE *a)
{
ASN1_item_free((ASN1_VALUE *)a, &X509_ATTRIBUTE_it);
}
-LCRYPTO_ALIAS(X509_ATTRIBUTE_free);
X509_ATTRIBUTE *
X509_ATTRIBUTE_dup(X509_ATTRIBUTE *x)
{
return ASN1_item_dup(&X509_ATTRIBUTE_it, x);
}
-LCRYPTO_ALIAS(X509_ATTRIBUTE_dup);
X509_ATTRIBUTE *
X509_ATTRIBUTE_create(int nid, int atrtype, void *value)
ASN1_TYPE_free(val);
return (NULL);
}
-LCRYPTO_ALIAS(X509_ATTRIBUTE_create);
-/* $OpenBSD: x_crl.c,v 1.40 2023/07/05 21:23:37 beck Exp $ */
+/* $OpenBSD: x_crl.c,v 1.41 2023/07/07 19:37:52 beck Exp $ */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
* All rights reserved.
*
return (X509_REVOKED *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&X509_REVOKED_it);
}
-LCRYPTO_ALIAS(d2i_X509_REVOKED);
int
i2d_X509_REVOKED(X509_REVOKED *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &X509_REVOKED_it);
}
-LCRYPTO_ALIAS(i2d_X509_REVOKED);
X509_REVOKED *
X509_REVOKED_new(void)
{
return (X509_REVOKED *)ASN1_item_new(&X509_REVOKED_it);
}
-LCRYPTO_ALIAS(X509_REVOKED_new);
void
X509_REVOKED_free(X509_REVOKED *a)
{
ASN1_item_free((ASN1_VALUE *)a, &X509_REVOKED_it);
}
-LCRYPTO_ALIAS(X509_REVOKED_free);
X509_REVOKED *
X509_REVOKED_dup(X509_REVOKED *a)
{
return ASN1_item_dup(&X509_REVOKED_it, a);
}
-LCRYPTO_ALIAS(X509_REVOKED_dup);
X509_CRL_INFO *
d2i_X509_CRL_INFO(X509_CRL_INFO **a, const unsigned char **in, long len)
return (X509_CRL_INFO *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&X509_CRL_INFO_it);
}
-LCRYPTO_ALIAS(d2i_X509_CRL_INFO);
int
i2d_X509_CRL_INFO(X509_CRL_INFO *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &X509_CRL_INFO_it);
}
-LCRYPTO_ALIAS(i2d_X509_CRL_INFO);
X509_CRL_INFO *
X509_CRL_INFO_new(void)
{
return (X509_CRL_INFO *)ASN1_item_new(&X509_CRL_INFO_it);
}
-LCRYPTO_ALIAS(X509_CRL_INFO_new);
void
X509_CRL_INFO_free(X509_CRL_INFO *a)
{
ASN1_item_free((ASN1_VALUE *)a, &X509_CRL_INFO_it);
}
-LCRYPTO_ALIAS(X509_CRL_INFO_free);
X509_CRL *
d2i_X509_CRL(X509_CRL **a, const unsigned char **in, long len)
return (X509_CRL *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&X509_CRL_it);
}
-LCRYPTO_ALIAS(d2i_X509_CRL);
int
i2d_X509_CRL(X509_CRL *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &X509_CRL_it);
}
-LCRYPTO_ALIAS(i2d_X509_CRL);
X509_CRL *
X509_CRL_new(void)
{
return (X509_CRL *)ASN1_item_new(&X509_CRL_it);
}
-LCRYPTO_ALIAS(X509_CRL_new);
void
X509_CRL_free(X509_CRL *a)
{
ASN1_item_free((ASN1_VALUE *)a, &X509_CRL_it);
}
-LCRYPTO_ALIAS(X509_CRL_free);
X509_CRL *
X509_CRL_dup(X509_CRL *x)
{
return ASN1_item_dup(&X509_CRL_it, x);
}
-LCRYPTO_ALIAS(X509_CRL_dup);
static int
X509_REVOKED_cmp(const X509_REVOKED * const *a, const X509_REVOKED * const *b)
inf->enc.modified = 1;
return 1;
}
-LCRYPTO_ALIAS(X509_CRL_add0_revoked);
int
X509_CRL_verify(X509_CRL *crl, EVP_PKEY *r)
return crl->meth->crl_verify(crl, r);
return 0;
}
-LCRYPTO_ALIAS(X509_CRL_verify);
int
X509_CRL_get0_by_serial(X509_CRL *crl, X509_REVOKED **ret,
return crl->meth->crl_lookup(crl, ret, serial, NULL);
return 0;
}
-LCRYPTO_ALIAS(X509_CRL_get0_by_serial);
int
X509_CRL_get0_by_cert(X509_CRL *crl, X509_REVOKED **ret, X509 *x)
X509_get_serialNumber(x), X509_get_issuer_name(x));
return 0;
}
-LCRYPTO_ALIAS(X509_CRL_get0_by_cert);
static int
def_crl_verify(X509_CRL *crl, EVP_PKEY *r)
else
default_crl_method = meth;
}
-LCRYPTO_ALIAS(X509_CRL_set_default_method);
X509_CRL_METHOD *
X509_CRL_METHOD_new(int (*crl_init)(X509_CRL *crl),
return m;
}
-LCRYPTO_ALIAS(X509_CRL_METHOD_new);
void
X509_CRL_METHOD_free(X509_CRL_METHOD *m)
return;
free(m);
}
-LCRYPTO_ALIAS(X509_CRL_METHOD_free);
void
X509_CRL_set_meth_data(X509_CRL *crl, void *dat)
{
crl->meth_data = dat;
}
-LCRYPTO_ALIAS(X509_CRL_set_meth_data);
void *
X509_CRL_get_meth_data(X509_CRL *crl)
{
return crl->meth_data;
}
-LCRYPTO_ALIAS(X509_CRL_get_meth_data);
int
X509_CRL_get_signature_nid(const X509_CRL *crl)
{
return OBJ_obj2nid(crl->sig_alg->algorithm);
}
-LCRYPTO_ALIAS(X509_CRL_get_signature_nid);
const STACK_OF(X509_EXTENSION) *
X509_CRL_get0_extensions(const X509_CRL *crl)
{
return crl->crl->extensions;
}
-LCRYPTO_ALIAS(X509_CRL_get0_extensions);
long
X509_CRL_get_version(const X509_CRL *crl)
{
return ASN1_INTEGER_get(crl->crl->version);
}
-LCRYPTO_ALIAS(X509_CRL_get_version);
const ASN1_TIME *
X509_CRL_get0_lastUpdate(const X509_CRL *crl)
{
return crl->crl->lastUpdate;
}
-LCRYPTO_ALIAS(X509_CRL_get0_lastUpdate);
ASN1_TIME *
X509_CRL_get_lastUpdate(X509_CRL *crl)
{
return crl->crl->lastUpdate;
}
-LCRYPTO_ALIAS(X509_CRL_get_lastUpdate);
const ASN1_TIME *
X509_CRL_get0_nextUpdate(const X509_CRL *crl)
{
return crl->crl->nextUpdate;
}
-LCRYPTO_ALIAS(X509_CRL_get0_nextUpdate);
ASN1_TIME *
X509_CRL_get_nextUpdate(X509_CRL *crl)
{
return crl->crl->nextUpdate;
}
-LCRYPTO_ALIAS(X509_CRL_get_nextUpdate);
X509_NAME *
X509_CRL_get_issuer(const X509_CRL *crl)
{
return crl->crl->issuer;
}
-LCRYPTO_ALIAS(X509_CRL_get_issuer);
STACK_OF(X509_REVOKED) *
X509_CRL_get_REVOKED(X509_CRL *crl)
{
return crl->crl->revoked;
}
-LCRYPTO_ALIAS(X509_CRL_get_REVOKED);
void
X509_CRL_get0_signature(const X509_CRL *crl, const ASN1_BIT_STRING **psig,
if (palg != NULL)
*palg = crl->sig_alg;
}
-LCRYPTO_ALIAS(X509_CRL_get0_signature);
const X509_ALGOR *
X509_CRL_get0_tbs_sigalg(const X509_CRL *crl)
{
return crl->crl->sig_alg;
}
-LCRYPTO_ALIAS(X509_CRL_get0_tbs_sigalg);
-/* $OpenBSD: x_exten.c,v 1.19 2023/07/05 21:23:37 beck Exp $ */
+/* $OpenBSD: x_exten.c,v 1.20 2023/07/07 19:37:52 beck Exp $ */
/* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
* project 2000.
*/
return (X509_EXTENSION *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&X509_EXTENSION_it);
}
-LCRYPTO_ALIAS(d2i_X509_EXTENSION);
int
i2d_X509_EXTENSION(X509_EXTENSION *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &X509_EXTENSION_it);
}
-LCRYPTO_ALIAS(i2d_X509_EXTENSION);
X509_EXTENSION *
X509_EXTENSION_new(void)
{
return (X509_EXTENSION *)ASN1_item_new(&X509_EXTENSION_it);
}
-LCRYPTO_ALIAS(X509_EXTENSION_new);
void
X509_EXTENSION_free(X509_EXTENSION *a)
{
ASN1_item_free((ASN1_VALUE *)a, &X509_EXTENSION_it);
}
-LCRYPTO_ALIAS(X509_EXTENSION_free);
X509_EXTENSIONS *
d2i_X509_EXTENSIONS(X509_EXTENSIONS **a, const unsigned char **in, long len)
return (X509_EXTENSIONS *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&X509_EXTENSIONS_it);
}
-LCRYPTO_ALIAS(d2i_X509_EXTENSIONS);
int
i2d_X509_EXTENSIONS(X509_EXTENSIONS *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &X509_EXTENSIONS_it);
}
-LCRYPTO_ALIAS(i2d_X509_EXTENSIONS);
X509_EXTENSION *
X509_EXTENSION_dup(X509_EXTENSION *x)
{
return ASN1_item_dup(&X509_EXTENSION_it, x);
}
-LCRYPTO_ALIAS(X509_EXTENSION_dup);
-/* $OpenBSD: x_info.c,v 1.19 2023/07/05 21:23:37 beck Exp $ */
+/* $OpenBSD: x_info.c,v 1.20 2023/07/07 19:37:52 beck Exp $ */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
* All rights reserved.
*
return ret;
}
-LCRYPTO_ALIAS(X509_INFO_new);
void
X509_INFO_free(X509_INFO *x)
free(x);
}
-LCRYPTO_ALIAS(X509_INFO_free);
-/* $OpenBSD: x_name.c,v 1.39 2023/07/05 21:23:37 beck Exp $ */
+/* $OpenBSD: x_name.c,v 1.40 2023/07/07 19:37:52 beck Exp $ */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
* All rights reserved.
*
return (X509_NAME_ENTRY *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&X509_NAME_ENTRY_it);
}
-LCRYPTO_ALIAS(d2i_X509_NAME_ENTRY);
int
i2d_X509_NAME_ENTRY(X509_NAME_ENTRY *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &X509_NAME_ENTRY_it);
}
-LCRYPTO_ALIAS(i2d_X509_NAME_ENTRY);
X509_NAME_ENTRY *
X509_NAME_ENTRY_new(void)
{
return (X509_NAME_ENTRY *)ASN1_item_new(&X509_NAME_ENTRY_it);
}
-LCRYPTO_ALIAS(X509_NAME_ENTRY_new);
void
X509_NAME_ENTRY_free(X509_NAME_ENTRY *a)
{
ASN1_item_free((ASN1_VALUE *)a, &X509_NAME_ENTRY_it);
}
-LCRYPTO_ALIAS(X509_NAME_ENTRY_free);
X509_NAME_ENTRY *
X509_NAME_ENTRY_dup(X509_NAME_ENTRY *x)
{
return ASN1_item_dup(&X509_NAME_ENTRY_it, x);
}
-LCRYPTO_ALIAS(X509_NAME_ENTRY_dup);
/* For the "Name" type we need a SEQUENCE OF { SET OF X509_NAME_ENTRY }
* so declare two template wrappers for this
return (X509_NAME *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&X509_NAME_it);
}
-LCRYPTO_ALIAS(d2i_X509_NAME);
int
i2d_X509_NAME(X509_NAME *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &X509_NAME_it);
}
-LCRYPTO_ALIAS(i2d_X509_NAME);
X509_NAME *
X509_NAME_new(void)
{
return (X509_NAME *)ASN1_item_new(&X509_NAME_it);
}
-LCRYPTO_ALIAS(X509_NAME_new);
void
X509_NAME_free(X509_NAME *a)
{
ASN1_item_free((ASN1_VALUE *)a, &X509_NAME_it);
}
-LCRYPTO_ALIAS(X509_NAME_free);
X509_NAME *
X509_NAME_dup(X509_NAME *x)
{
return ASN1_item_dup(&X509_NAME_it, x);
}
-LCRYPTO_ALIAS(X509_NAME_dup);
static int
x509_name_ex_new(ASN1_VALUE **val, const ASN1_ITEM *it)
*xn = name;
return 1;
}
-LCRYPTO_ALIAS(X509_NAME_set);
int
X509_NAME_get0_der(X509_NAME *nm, const unsigned char **pder, size_t *pderlen)
*pderlen = nm->bytes->length;
return 1;
}
-LCRYPTO_ALIAS(X509_NAME_get0_der);
-/* $OpenBSD: x_pkey.c,v 1.22 2023/07/05 21:23:37 beck Exp $ */
+/* $OpenBSD: x_pkey.c,v 1.23 2023/07/07 19:37:53 beck Exp $ */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
* All rights reserved.
*
}
return NULL;
}
-LCRYPTO_ALIAS(X509_PKEY_new);
void
X509_PKEY_free(X509_PKEY *x)
free(x->key_data);
free(x);
}
-LCRYPTO_ALIAS(X509_PKEY_free);
-/* $OpenBSD: x_pubkey.c,v 1.34 2023/07/05 21:23:37 beck Exp $ */
+/* $OpenBSD: x_pubkey.c,v 1.35 2023/07/07 19:37:53 beck Exp $ */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
* All rights reserved.
*
return (X509_PUBKEY *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&X509_PUBKEY_it);
}
-LCRYPTO_ALIAS(d2i_X509_PUBKEY);
int
i2d_X509_PUBKEY(X509_PUBKEY *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &X509_PUBKEY_it);
}
-LCRYPTO_ALIAS(i2d_X509_PUBKEY);
X509_PUBKEY *
X509_PUBKEY_new(void)
{
return (X509_PUBKEY *)ASN1_item_new(&X509_PUBKEY_it);
}
-LCRYPTO_ALIAS(X509_PUBKEY_new);
void
X509_PUBKEY_free(X509_PUBKEY *a)
{
ASN1_item_free((ASN1_VALUE *)a, &X509_PUBKEY_it);
}
-LCRYPTO_ALIAS(X509_PUBKEY_free);
int
X509_PUBKEY_set(X509_PUBKEY **x, EVP_PKEY *pkey)
X509_PUBKEY_free(pk);
return 0;
}
-LCRYPTO_ALIAS(X509_PUBKEY_set);
EVP_PKEY *
X509_PUBKEY_get0(X509_PUBKEY *key)
EVP_PKEY_free(ret);
return (NULL);
}
-LCRYPTO_ALIAS(X509_PUBKEY_get0);
EVP_PKEY *
X509_PUBKEY_get(X509_PUBKEY *key)
return pkey;
}
-LCRYPTO_ALIAS(X509_PUBKEY_get);
/*
* Decode an X509_PUBKEY into the specified key type.
return (EVP_PKEY *)ASN1_item_d2i((ASN1_VALUE **)pkey, in, len,
&EVP_PKEY_PUBKEY_it);
}
-LCRYPTO_ALIAS(d2i_PUBKEY);
int
i2d_PUBKEY(EVP_PKEY *pkey, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)pkey, out, &EVP_PKEY_PUBKEY_it);
}
-LCRYPTO_ALIAS(i2d_PUBKEY);
EVP_PKEY *
d2i_PUBKEY_bio(BIO *bp, EVP_PKEY **pkey)
return (EVP_PKEY *)ASN1_item_d2i_bio(&EVP_PKEY_PUBKEY_it, bp,
(ASN1_VALUE **)pkey);
}
-LCRYPTO_ALIAS(d2i_PUBKEY_bio);
int
i2d_PUBKEY_bio(BIO *bp, EVP_PKEY *pkey)
{
return ASN1_item_i2d_bio(&EVP_PKEY_PUBKEY_it, bp, (ASN1_VALUE *)pkey);
}
-LCRYPTO_ALIAS(i2d_PUBKEY_bio);
EVP_PKEY *
d2i_PUBKEY_fp(FILE *fp, EVP_PKEY **pkey)
return (EVP_PKEY *)ASN1_item_d2i_fp(&EVP_PKEY_PUBKEY_it, fp,
(ASN1_VALUE **)pkey);
}
-LCRYPTO_ALIAS(d2i_PUBKEY_fp);
int
i2d_PUBKEY_fp(FILE *fp, EVP_PKEY *pkey)
{
return ASN1_item_i2d_fp(&EVP_PKEY_PUBKEY_it, fp, (ASN1_VALUE *)pkey);
}
-LCRYPTO_ALIAS(i2d_PUBKEY_fp);
/*
* The following are equivalents but which return RSA and DSA keys.
return (RSA *)ASN1_item_d2i((ASN1_VALUE **)rsa, in, len,
&RSA_PUBKEY_it);
}
-LCRYPTO_ALIAS(d2i_RSA_PUBKEY);
int
i2d_RSA_PUBKEY(RSA *rsa, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)rsa, out, &RSA_PUBKEY_it);
}
-LCRYPTO_ALIAS(i2d_RSA_PUBKEY);
RSA *
d2i_RSA_PUBKEY_bio(BIO *bp, RSA **rsa)
{
return (RSA *)ASN1_item_d2i_bio(&RSA_PUBKEY_it, bp, (ASN1_VALUE **)rsa);
}
-LCRYPTO_ALIAS(d2i_RSA_PUBKEY_bio);
int
i2d_RSA_PUBKEY_bio(BIO *bp, RSA *rsa)
{
return ASN1_item_i2d_bio(&RSA_PUBKEY_it, bp, (ASN1_VALUE *)rsa);
}
-LCRYPTO_ALIAS(i2d_RSA_PUBKEY_bio);
RSA *
d2i_RSA_PUBKEY_fp(FILE *fp, RSA **rsa)
{
return (RSA *)ASN1_item_d2i_fp(&RSA_PUBKEY_it, fp, (ASN1_VALUE **)rsa);
}
-LCRYPTO_ALIAS(d2i_RSA_PUBKEY_fp);
int
i2d_RSA_PUBKEY_fp(FILE *fp, RSA *rsa)
{
return ASN1_item_i2d_fp(&RSA_PUBKEY_it, fp, (ASN1_VALUE *)rsa);
}
-LCRYPTO_ALIAS(i2d_RSA_PUBKEY_fp);
#endif
#ifndef OPENSSL_NO_DSA
return (DSA *)ASN1_item_d2i((ASN1_VALUE **)dsa, in, len,
&DSA_PUBKEY_it);
}
-LCRYPTO_ALIAS(d2i_DSA_PUBKEY);
int
i2d_DSA_PUBKEY(DSA *dsa, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)dsa, out, &DSA_PUBKEY_it);
}
-LCRYPTO_ALIAS(i2d_DSA_PUBKEY);
DSA *
d2i_DSA_PUBKEY_bio(BIO *bp, DSA **dsa)
{
return (DSA *)ASN1_item_d2i_bio(&DSA_PUBKEY_it, bp, (ASN1_VALUE **)dsa);
}
-LCRYPTO_ALIAS(d2i_DSA_PUBKEY_bio);
int
i2d_DSA_PUBKEY_bio(BIO *bp, DSA *dsa)
{
return ASN1_item_i2d_bio(&DSA_PUBKEY_it, bp, (ASN1_VALUE *)dsa);
}
-LCRYPTO_ALIAS(i2d_DSA_PUBKEY_bio);
DSA *
d2i_DSA_PUBKEY_fp(FILE *fp, DSA **dsa)
{
return (DSA *)ASN1_item_d2i_fp(&DSA_PUBKEY_it, fp, (ASN1_VALUE **)dsa);
}
-LCRYPTO_ALIAS(d2i_DSA_PUBKEY_fp);
int
i2d_DSA_PUBKEY_fp(FILE *fp, DSA *dsa)
{
return ASN1_item_i2d_fp(&DSA_PUBKEY_it, fp, (ASN1_VALUE *)dsa);
}
-LCRYPTO_ALIAS(i2d_DSA_PUBKEY_fp);
#endif
return (EC_KEY *)ASN1_item_d2i((ASN1_VALUE **)ec, in, len,
&EC_PUBKEY_it);
}
-LCRYPTO_ALIAS(d2i_EC_PUBKEY);
int
i2d_EC_PUBKEY(EC_KEY *ec, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)ec, out, &EC_PUBKEY_it);
}
-LCRYPTO_ALIAS(i2d_EC_PUBKEY);
EC_KEY *
d2i_EC_PUBKEY_bio(BIO *bp, EC_KEY **ec)
{
return (EC_KEY *)ASN1_item_d2i_bio(&EC_PUBKEY_it, bp, (ASN1_VALUE **)ec);
}
-LCRYPTO_ALIAS(d2i_EC_PUBKEY_bio);
int
i2d_EC_PUBKEY_bio(BIO *bp, EC_KEY *ec)
{
return ASN1_item_i2d_bio(&EC_PUBKEY_it, bp, (ASN1_VALUE *)ec);
}
-LCRYPTO_ALIAS(i2d_EC_PUBKEY_bio);
EC_KEY *
d2i_EC_PUBKEY_fp(FILE *fp, EC_KEY **ec)
{
return (EC_KEY *)ASN1_item_d2i_fp(&EC_PUBKEY_it, fp, (ASN1_VALUE **)ec);
}
-LCRYPTO_ALIAS(d2i_EC_PUBKEY_fp);
int
i2d_EC_PUBKEY_fp(FILE *fp, EC_KEY *ec)
{
return ASN1_item_i2d_fp(&EC_PUBKEY_it, fp, (ASN1_VALUE *)ec);
}
-LCRYPTO_ALIAS(i2d_EC_PUBKEY_fp);
#endif
int
return asn1_abs_set_unused_bits(pub->public_key, 0);
}
-LCRYPTO_ALIAS(X509_PUBKEY_set0_param);
int
X509_PUBKEY_get0_param(ASN1_OBJECT **ppkalg, const unsigned char **pk,
*pa = pub->algor;
return 1;
}
-LCRYPTO_ALIAS(X509_PUBKEY_get0_param);
-/* $OpenBSD: x_req.c,v 1.20 2023/07/05 21:23:37 beck Exp $ */
+/* $OpenBSD: x_req.c,v 1.21 2023/07/07 19:37:53 beck Exp $ */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
* All rights reserved.
*
return (X509_REQ_INFO *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&X509_REQ_INFO_it);
}
-LCRYPTO_ALIAS(d2i_X509_REQ_INFO);
int
i2d_X509_REQ_INFO(X509_REQ_INFO *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &X509_REQ_INFO_it);
}
-LCRYPTO_ALIAS(i2d_X509_REQ_INFO);
X509_REQ_INFO *
X509_REQ_INFO_new(void)
{
return (X509_REQ_INFO *)ASN1_item_new(&X509_REQ_INFO_it);
}
-LCRYPTO_ALIAS(X509_REQ_INFO_new);
void
X509_REQ_INFO_free(X509_REQ_INFO *a)
{
ASN1_item_free((ASN1_VALUE *)a, &X509_REQ_INFO_it);
}
-LCRYPTO_ALIAS(X509_REQ_INFO_free);
static const ASN1_AUX X509_REQ_aux = {
.app_data = NULL,
return (X509_REQ *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&X509_REQ_it);
}
-LCRYPTO_ALIAS(d2i_X509_REQ);
int
i2d_X509_REQ(X509_REQ *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &X509_REQ_it);
}
-LCRYPTO_ALIAS(i2d_X509_REQ);
X509_REQ *
X509_REQ_new(void)
{
return (X509_REQ *)ASN1_item_new(&X509_REQ_it);
}
-LCRYPTO_ALIAS(X509_REQ_new);
void
X509_REQ_free(X509_REQ *a)
{
ASN1_item_free((ASN1_VALUE *)a, &X509_REQ_it);
}
-LCRYPTO_ALIAS(X509_REQ_free);
X509_REQ *
X509_REQ_dup(X509_REQ *x)
{
return ASN1_item_dup(&X509_REQ_it, x);
}
-LCRYPTO_ALIAS(X509_REQ_dup);
int
X509_REQ_get_signature_nid(const X509_REQ *req)
{
return OBJ_obj2nid(req->sig_alg->algorithm);
}
-LCRYPTO_ALIAS(X509_REQ_get_signature_nid);
void
X509_REQ_get0_signature(const X509_REQ *req, const ASN1_BIT_STRING **psig,
if (palg != NULL)
*palg = req->sig_alg;
}
-LCRYPTO_ALIAS(X509_REQ_get0_signature);
-/* $OpenBSD: x_sig.c,v 1.15 2023/07/05 21:23:37 beck Exp $ */
+/* $OpenBSD: x_sig.c,v 1.16 2023/07/07 19:37:53 beck Exp $ */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
* All rights reserved.
*
return (X509_SIG *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&X509_SIG_it);
}
-LCRYPTO_ALIAS(d2i_X509_SIG);
int
i2d_X509_SIG(X509_SIG *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &X509_SIG_it);
}
-LCRYPTO_ALIAS(i2d_X509_SIG);
X509_SIG *
X509_SIG_new(void)
{
return (X509_SIG *)ASN1_item_new(&X509_SIG_it);
}
-LCRYPTO_ALIAS(X509_SIG_new);
void
X509_SIG_free(X509_SIG *a)
{
ASN1_item_free((ASN1_VALUE *)a, &X509_SIG_it);
}
-LCRYPTO_ALIAS(X509_SIG_free);
void
X509_SIG_get0(const X509_SIG *sig, const X509_ALGOR **palg,
if (pdigest != NULL)
*pdigest = sig->digest;
}
-LCRYPTO_ALIAS(X509_SIG_get0);
void
X509_SIG_getm(X509_SIG *sig, X509_ALGOR **palg, ASN1_OCTET_STRING **pdigest)
if (pdigest != NULL)
*pdigest = sig->digest;
}
-LCRYPTO_ALIAS(X509_SIG_getm);
-/* $OpenBSD: x_spki.c,v 1.12 2023/07/05 21:23:37 beck Exp $ */
+/* $OpenBSD: x_spki.c,v 1.13 2023/07/07 19:37:53 beck Exp $ */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
* All rights reserved.
*
return (NETSCAPE_SPKAC *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&NETSCAPE_SPKAC_it);
}
-LCRYPTO_ALIAS(d2i_NETSCAPE_SPKAC);
int
i2d_NETSCAPE_SPKAC(NETSCAPE_SPKAC *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &NETSCAPE_SPKAC_it);
}
-LCRYPTO_ALIAS(i2d_NETSCAPE_SPKAC);
NETSCAPE_SPKAC *
NETSCAPE_SPKAC_new(void)
{
return (NETSCAPE_SPKAC *)ASN1_item_new(&NETSCAPE_SPKAC_it);
}
-LCRYPTO_ALIAS(NETSCAPE_SPKAC_new);
void
NETSCAPE_SPKAC_free(NETSCAPE_SPKAC *a)
{
ASN1_item_free((ASN1_VALUE *)a, &NETSCAPE_SPKAC_it);
}
-LCRYPTO_ALIAS(NETSCAPE_SPKAC_free);
static const ASN1_TEMPLATE NETSCAPE_SPKI_seq_tt[] = {
{
return (NETSCAPE_SPKI *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&NETSCAPE_SPKI_it);
}
-LCRYPTO_ALIAS(d2i_NETSCAPE_SPKI);
int
i2d_NETSCAPE_SPKI(NETSCAPE_SPKI *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &NETSCAPE_SPKI_it);
}
-LCRYPTO_ALIAS(i2d_NETSCAPE_SPKI);
NETSCAPE_SPKI *
NETSCAPE_SPKI_new(void)
{
return (NETSCAPE_SPKI *)ASN1_item_new(&NETSCAPE_SPKI_it);
}
-LCRYPTO_ALIAS(NETSCAPE_SPKI_new);
void
NETSCAPE_SPKI_free(NETSCAPE_SPKI *a)
{
ASN1_item_free((ASN1_VALUE *)a, &NETSCAPE_SPKI_it);
}
-LCRYPTO_ALIAS(NETSCAPE_SPKI_free);
-/* $OpenBSD: x_val.c,v 1.12 2023/07/05 21:23:37 beck Exp $ */
+/* $OpenBSD: x_val.c,v 1.13 2023/07/07 19:37:53 beck Exp $ */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
* All rights reserved.
*
return (X509_VAL *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&X509_VAL_it);
}
-LCRYPTO_ALIAS(d2i_X509_VAL);
int
i2d_X509_VAL(X509_VAL *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &X509_VAL_it);
}
-LCRYPTO_ALIAS(i2d_X509_VAL);
X509_VAL *
X509_VAL_new(void)
{
return (X509_VAL *)ASN1_item_new(&X509_VAL_it);
}
-LCRYPTO_ALIAS(X509_VAL_new);
void
X509_VAL_free(X509_VAL *a)
{
ASN1_item_free((ASN1_VALUE *)a, &X509_VAL_it);
}
-LCRYPTO_ALIAS(X509_VAL_free);
-/* $OpenBSD: x_x509.c,v 1.36 2023/07/05 21:23:37 beck Exp $ */
+/* $OpenBSD: x_x509.c,v 1.37 2023/07/07 19:37:53 beck Exp $ */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
* All rights reserved.
*
return (X509_CINF *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&X509_CINF_it);
}
-LCRYPTO_ALIAS(d2i_X509_CINF);
int
i2d_X509_CINF(X509_CINF *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &X509_CINF_it);
}
-LCRYPTO_ALIAS(i2d_X509_CINF);
X509_CINF *
X509_CINF_new(void)
{
return (X509_CINF *)ASN1_item_new(&X509_CINF_it);
}
-LCRYPTO_ALIAS(X509_CINF_new);
void
X509_CINF_free(X509_CINF *a)
{
ASN1_item_free((ASN1_VALUE *)a, &X509_CINF_it);
}
-LCRYPTO_ALIAS(X509_CINF_free);
/* X509 top level structure needs a bit of customisation */
static int
return (X509 *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&X509_it);
}
-LCRYPTO_ALIAS(d2i_X509);
int
i2d_X509(X509 *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &X509_it);
}
-LCRYPTO_ALIAS(i2d_X509);
X509 *
X509_new(void)
{
return (X509 *)ASN1_item_new(&X509_it);
}
-LCRYPTO_ALIAS(X509_new);
void
X509_free(X509 *a)
{
ASN1_item_free((ASN1_VALUE *)a, &X509_it);
}
-LCRYPTO_ALIAS(X509_free);
X509 *
X509_dup(X509 *x)
{
return ASN1_item_dup(&X509_it, x);
}
-LCRYPTO_ALIAS(X509_dup);
int
X509_get_ex_new_index(long argl, void *argp, CRYPTO_EX_new *new_func,
return CRYPTO_get_ex_new_index(CRYPTO_EX_INDEX_X509, argl, argp,
new_func, dup_func, free_func);
}
-LCRYPTO_ALIAS(X509_get_ex_new_index);
int
X509_set_ex_data(X509 *r, int idx, void *arg)
{
return (CRYPTO_set_ex_data(&r->ex_data, idx, arg));
}
-LCRYPTO_ALIAS(X509_set_ex_data);
void *
X509_get_ex_data(X509 *r, int idx)
{
return (CRYPTO_get_ex_data(&r->ex_data, idx));
}
-LCRYPTO_ALIAS(X509_get_ex_data);
/* X509_AUX ASN1 routines. X509_AUX is the name given to
* a certificate with extra info tagged on the end. Since these
X509_free(ret);
return NULL;
}
-LCRYPTO_ALIAS(d2i_X509_AUX);
int
i2d_X509_AUX(X509 *a, unsigned char **pp)
length += i2d_X509_CERT_AUX(a->aux, pp);
return length;
}
-LCRYPTO_ALIAS(i2d_X509_AUX);
int
i2d_re_X509_tbs(X509 *x, unsigned char **pp)
x->cert_info->enc.modified = 1;
return i2d_X509_CINF(x->cert_info, pp);
}
-LCRYPTO_ALIAS(i2d_re_X509_tbs);
void
X509_get0_signature(const ASN1_BIT_STRING **psig, const X509_ALGOR **palg,
if (palg != NULL)
*palg = x->sig_alg;
}
-LCRYPTO_ALIAS(X509_get0_signature);
int
X509_get_signature_nid(const X509 *x)
{
return OBJ_obj2nid(x->sig_alg->algorithm);
}
-LCRYPTO_ALIAS(X509_get_signature_nid);
-/* $OpenBSD: x_x509a.c,v 1.20 2023/07/05 21:23:37 beck Exp $ */
+/* $OpenBSD: x_x509a.c,v 1.21 2023/07/07 19:37:53 beck Exp $ */
/* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
* project 1999.
*/
return (X509_CERT_AUX *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&X509_CERT_AUX_it);
}
-LCRYPTO_ALIAS(d2i_X509_CERT_AUX);
int
i2d_X509_CERT_AUX(X509_CERT_AUX *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &X509_CERT_AUX_it);
}
-LCRYPTO_ALIAS(i2d_X509_CERT_AUX);
X509_CERT_AUX *
X509_CERT_AUX_new(void)
{
return (X509_CERT_AUX *)ASN1_item_new(&X509_CERT_AUX_it);
}
-LCRYPTO_ALIAS(X509_CERT_AUX_new);
void
X509_CERT_AUX_free(X509_CERT_AUX *a)
{
ASN1_item_free((ASN1_VALUE *)a, &X509_CERT_AUX_it);
}
-LCRYPTO_ALIAS(X509_CERT_AUX_free);
static X509_CERT_AUX *
aux_get(X509 *x)
return 0;
return ASN1_STRING_set(aux->alias, name, len);
}
-LCRYPTO_ALIAS(X509_alias_set1);
int
X509_keyid_set1(X509 *x, const unsigned char *id, int len)
return 0;
return ASN1_STRING_set(aux->keyid, id, len);
}
-LCRYPTO_ALIAS(X509_keyid_set1);
unsigned char *
X509_alias_get0(X509 *x, int *len)
*len = x->aux->alias->length;
return x->aux->alias->data;
}
-LCRYPTO_ALIAS(X509_alias_get0);
unsigned char *
X509_keyid_get0(X509 *x, int *len)
*len = x->aux->keyid->length;
return x->aux->keyid->data;
}
-LCRYPTO_ALIAS(X509_keyid_get0);
int
X509_add1_trust_object(X509 *x, const ASN1_OBJECT *obj)
ASN1_OBJECT_free(objtmp);
return 0;
}
-LCRYPTO_ALIAS(X509_add1_trust_object);
int
X509_add1_reject_object(X509 *x, const ASN1_OBJECT *obj)
ASN1_OBJECT_free(objtmp);
return 0;
}
-LCRYPTO_ALIAS(X509_add1_reject_object);
void
X509_trust_clear(X509 *x)
x->aux->trust = NULL;
}
}
-LCRYPTO_ALIAS(X509_trust_clear);
void
X509_reject_clear(X509 *x)
x->aux->reject = NULL;
}
}
-LCRYPTO_ALIAS(X509_reject_clear);
-/* $OpenBSD: b_dump.c,v 1.24 2023/07/05 21:23:37 beck Exp $ */
+/* $OpenBSD: b_dump.c,v 1.25 2023/07/07 19:37:53 beck Exp $ */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
* All rights reserved.
*
{
return BIO_dump_indent_cb(cb, u, s, len, 0);
}
-LCRYPTO_ALIAS(BIO_dump_cb);
int
BIO_dump_indent_cb(int (*cb)(const void *data, size_t len, void *u),
#endif
return (ret);
}
-LCRYPTO_ALIAS(BIO_dump_indent_cb);
static int
write_fp(const void *data, size_t len, void *fp)
-/* $OpenBSD: bio_lib.c,v 1.45 2023/07/05 21:23:37 beck Exp $ */
+/* $OpenBSD: bio_lib.c,v 1.46 2023/07/07 19:37:53 beck Exp $ */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
* All rights reserved.
*
return CRYPTO_get_ex_new_index(CRYPTO_EX_INDEX_BIO, argl, argp,
new_func, dup_func, free_func);
}
-LCRYPTO_ALIAS(BIO_get_ex_new_index);
int
BIO_set_ex_data(BIO *bio, int idx, void *data)
-/* $OpenBSD: bss_bio.c,v 1.26 2023/07/05 21:23:37 beck Exp $ */
+/* $OpenBSD: bss_bio.c,v 1.27 2023/07/07 19:37:53 beck Exp $ */
/* ====================================================================
* Copyright (c) 1998-2003 The OpenSSL Project. All rights reserved.
*
*bio2_p = bio2;
return ret;
}
-LCRYPTO_ALIAS(BIO_new_bio_pair);
size_t
BIO_ctrl_get_write_guarantee(BIO *bio)
-/* $OpenBSD: bss_conn.c,v 1.38 2023/07/05 21:23:37 beck Exp $ */
+/* $OpenBSD: bss_conn.c,v 1.39 2023/07/07 19:37:53 beck Exp $ */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
* All rights reserved.
*
memset((char *)&ret->them, 0, sizeof(ret->them));
return (ret);
}
-LCRYPTO_ALIAS(BIO_CONNECT_new);
void
BIO_CONNECT_free(BIO_CONNECT *a)
free(a->param_port);
free(a);
}
-LCRYPTO_ALIAS(BIO_CONNECT_free);
const BIO_METHOD *
BIO_s_connect(void)
-/* $OpenBSD: chacha-merged.c,v 1.10 2021/10/22 17:43:00 tb Exp $ */
+/* $OpenBSD: chacha-merged.c,v 1.11 2023/07/07 19:37:53 beck Exp $ */
/*
chacha-merged.c version 20080118
D. J. Bernstein
U32TO8_LITTLE(subkey + 24, x[14]);
U32TO8_LITTLE(subkey + 28, x[15]);
}
+LCRYPTO_ALIAS(CRYPTO_hchacha_20);
-/* $OpenBSD: ec_asn1.c,v 1.47 2023/07/07 13:54:45 beck Exp $ */
+/* $OpenBSD: ec_asn1.c,v 1.48 2023/07/07 19:37:53 beck Exp $ */
/*
* Written by Nils Larsch for the OpenSSL project.
*/
{
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 */
-/* $OpenBSD: ec_lib.c,v 1.63 2023/07/07 13:54:45 beck Exp $ */
+/* $OpenBSD: ec_lib.c,v 1.64 2023/07/07 19:37:53 beck Exp $ */
/*
* Originally written by Bodo Moeller for the OpenSSL project.
*/
{
EC_GROUP_free(group);
}
-LCRYPTO_ALIAS(EC_GROUP_clear_free);
int
EC_GROUP_copy(EC_GROUP *dest, const EC_GROUP *src)
{
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)
{
EC_POINT_free(point);
}
-LCRYPTO_ALIAS(EC_POINT_clear_free);
int
EC_POINT_copy(EC_POINT *dest, const EC_POINT *src)
{
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 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 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,
-/* $OpenBSD: ec_oct.c,v 1.15 2023/07/07 13:54:45 beck Exp $ */
+/* $OpenBSD: ec_oct.c,v 1.16 2023/07/07 19:37:53 beck Exp $ */
/*
* Originally written by Bodo Moeller for the OpenSSL project.
*/
{
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,
-/* $OpenBSD: err.c,v 1.53 2023/07/07 13:54:45 beck Exp $ */
+/* $OpenBSD: err.c,v 1.54 2023/07/07 19:37:53 beck Exp $ */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
* All rights reserved.
*
err_fns_check();
return ERRFN(err_get)(0);
}
+LCRYPTO_ALIAS(ERR_get_string_table);
LHASH_OF(ERR_STATE) *ERR_get_err_state_table(void)
{
err_fns_check();
return ERRFN(thread_get)(0);
}
+LCRYPTO_ALIAS(ERR_get_err_state_table);
void
ERR_release_err_state_table(LHASH_OF(ERR_STATE) **hash)
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)
-/* $OpenBSD: bio_b64.c,v 1.27 2023/07/07 13:54:45 beck Exp $ */
+/* $OpenBSD: bio_b64.c,v 1.28 2023/07/07 19:37:53 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.28 2023/07/07 13:54:45 beck Exp $ */
+/* $OpenBSD: bio_enc.c,v 1.29 2023/07/07 19:37:53 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.20 2023/07/07 13:54:45 beck Exp $ */
+/* $OpenBSD: bio_md.c,v 1.21 2023/07/07 19:37:53 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.30 2023/07/07 13:54:45 beck Exp $ */
+/* $OpenBSD: c_all.c,v 1.31 2023/07/07 19:37:53 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.9 2023/07/07 13:54:45 beck Exp $ */
+/* $OpenBSD: cipher_method_lib.c,v 1.10 2023/07/07 19:37:53 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.37 2023/07/07 13:54:45 beck Exp $ */
+/* $OpenBSD: digest.c,v 1.38 2023/07/07 19:37:53 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.52 2023/07/07 13:54:45 beck Exp $ */
+/* $OpenBSD: e_aes.c,v 1.53 2023/07/07 19:37:53 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.18 2023/07/07 13:54:45 beck Exp $ */
+/* $OpenBSD: e_aes_cbc_hmac_sha1.c,v 1.19 2023/07/07 19:37:53 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.16 2023/07/07 13:54:45 beck Exp $ */
+/* $OpenBSD: e_bf.c,v 1.17 2023/07/07 19:37:53 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.17 2023/07/07 13:54:45 beck Exp $ */
+/* $OpenBSD: e_camellia.c,v 1.18 2023/07/07 19:37:53 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.15 2023/07/07 13:54:45 beck Exp $ */
+/* $OpenBSD: e_cast.c,v 1.16 2023/07/07 19:37:53 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.11 2023/07/07 13:54:45 beck Exp $ */
+/* $OpenBSD: e_chacha.c,v 1.12 2023/07/07 19:37:53 beck Exp $ */
/*
* Copyright (c) 2014 Joel Sing <jsing@openbsd.org>
*
{
return (&chacha20_cipher);
}
-LCRYPTO_ALIAS(EVP_chacha20);
#endif
-/* $OpenBSD: e_chacha20poly1305.c,v 1.29 2023/07/07 13:54:45 beck Exp $ */
+/* $OpenBSD: e_chacha20poly1305.c,v 1.30 2023/07/07 19:37:53 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.21 2023/07/07 13:54:45 beck Exp $ */
+/* $OpenBSD: e_des.c,v 1.22 2023/07/07 19:37:53 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.27 2023/07/07 13:54:45 beck Exp $ */
+/* $OpenBSD: e_des3.c,v 1.28 2023/07/07 19:37:53 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.12 2023/07/07 13:54:45 beck Exp $ */
+/* $OpenBSD: e_gost2814789.c,v 1.13 2023/07/07 19:37:53 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.19 2023/07/07 13:54:45 beck Exp $ */
+/* $OpenBSD: e_idea.c,v 1.20 2023/07/07 19:37:53 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.17 2023/07/07 13:54:45 beck Exp $ */
+/* $OpenBSD: e_null.c,v 1.18 2023/07/07 19:37:53 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.21 2023/07/07 13:54:45 beck Exp $ */
+/* $OpenBSD: e_rc2.c,v 1.22 2023/07/07 19:37:53 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.16 2023/07/07 13:54:45 beck Exp $ */
+/* $OpenBSD: e_rc4.c,v 1.17 2023/07/07 19:37:53 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.11 2023/07/07 13:54:45 beck Exp $ */
+/* $OpenBSD: e_rc4_hmac_md5.c,v 1.12 2023/07/07 19:37:53 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.8 2023/07/07 13:54:45 beck Exp $ */
+/* $OpenBSD: e_sm4.c,v 1.9 2023/07/07 19:37:53 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.14 2023/07/07 13:54:45 beck Exp $ */
+/* $OpenBSD: e_xcbc_d.c,v 1.15 2023/07/07 19:37:53 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.31 2023/07/07 13:54:45 beck Exp $ */
+/* $OpenBSD: encode.c,v 1.32 2023/07/07 19:37:53 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.9 2023/07/07 13:54:45 beck Exp $ */
+/* $OpenBSD: evp_aead.c,v 1.10 2023/07/07 19:37:53 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.51 2023/07/07 13:54:45 beck Exp $ */
+/* $OpenBSD: evp_enc.c,v 1.52 2023/07/07 19:37:53 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.31 2023/07/07 13:54:45 beck Exp $ */
+/* $OpenBSD: evp_err.c,v 1.32 2023/07/07 19:37:53 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.29 2023/07/07 13:54:45 beck Exp $ */
+/* $OpenBSD: evp_key.c,v 1.30 2023/07/07 19:37:53 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.26 2023/07/07 13:54:45 beck Exp $ */
+/* $OpenBSD: evp_lib.c,v 1.27 2023/07/07 19:37:53 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.28 2023/07/07 13:54:45 beck Exp $ */
+/* $OpenBSD: evp_pbe.c,v 1.29 2023/07/07 19:37:53 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.26 2023/07/07 13:54:45 beck Exp $ */
+/* $OpenBSD: evp_pkey.c,v 1.27 2023/07/07 19:37:53 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.5 2023/07/07 13:54:45 beck Exp $ */
+/* $OpenBSD: m_gost2814789.c,v 1.6 2023/07/07 19:37:53 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.6 2023/07/07 13:54:45 beck Exp $ */
+/* $OpenBSD: m_gostr341194.c,v 1.7 2023/07/07 19:37:53 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.20 2023/07/07 13:54:45 beck Exp $ */
+/* $OpenBSD: m_md4.c,v 1.21 2023/07/07 19:37:53 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.19 2023/07/07 13:54:45 beck Exp $ */
+/* $OpenBSD: m_md5.c,v 1.20 2023/07/07 19:37:53 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.6 2023/07/07 13:54:45 beck Exp $ */
+/* $OpenBSD: m_md5_sha1.c,v 1.7 2023/07/07 19:37:53 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.13 2023/07/07 13:54:45 beck Exp $ */
+/* $OpenBSD: m_null.c,v 1.14 2023/07/07 19:37:53 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.16 2023/07/07 13:54:45 beck Exp $ */
+/* $OpenBSD: m_ripemd.c,v 1.17 2023/07/07 19:37:53 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.24 2023/07/07 13:54:45 beck Exp $ */
+/* $OpenBSD: m_sha1.c,v 1.25 2023/07/07 19:37:53 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.2 2023/07/07 13:54:45 beck Exp $ */
+/* $OpenBSD: m_sha3.c,v 1.3 2023/07/07 19:37:53 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.12 2023/07/07 13:54:45 beck Exp $ */
+/* $OpenBSD: m_sigver.c,v 1.13 2023/07/07 19:37:53 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.5 2023/07/07 13:54:46 beck Exp $ */
+/* $OpenBSD: m_sm3.c,v 1.6 2023/07/07 19:37:53 beck Exp $ */
/*
* Copyright (c) 2018, Ribose Inc
*
{
return &sm3_md;
}
-LCRYPTO_ALIAS(EVP_sm3);
#endif /* OPENSSL_NO_SM3 */
-/* $OpenBSD: m_streebog.c,v 1.6 2023/07/07 13:54:46 beck Exp $ */
+/* $OpenBSD: m_streebog.c,v 1.7 2023/07/07 19:37:54 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.12 2023/07/07 13:54:46 beck Exp $ */
+/* $OpenBSD: m_wp.c,v 1.13 2023/07/07 19:37:54 beck Exp $ */
#include <stdio.h>
{
return (&whirlpool_md);
}
-LCRYPTO_ALIAS(EVP_whirlpool);
#endif
-/* $OpenBSD: names.c,v 1.18 2023/07/07 13:54:46 beck Exp $ */
+/* $OpenBSD: names.c,v 1.19 2023/07/07 19:37:54 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.22 2023/07/07 13:54:46 beck Exp $ */
+/* $OpenBSD: p5_crpt.c,v 1.23 2023/07/07 19:37:54 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.26 2023/07/07 13:54:46 beck Exp $ */
+/* $OpenBSD: p5_crpt2.c,v 1.27 2023/07/07 19:37:54 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.14 2023/07/07 13:54:46 beck Exp $ */
+/* $OpenBSD: p_dec.c,v 1.15 2023/07/07 19:37:54 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.14 2023/07/07 13:54:46 beck Exp $ */
+/* $OpenBSD: p_enc.c,v 1.15 2023/07/07 19:37:54 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.33 2023/07/07 13:54:46 beck Exp $ */
+/* $OpenBSD: p_lib.c,v 1.34 2023/07/07 19:37:54 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.22 2023/07/07 13:54:46 beck Exp $ */
+/* $OpenBSD: p_open.c,v 1.23 2023/07/07 19:37:54 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.15 2023/07/07 13:54:46 beck Exp $ */
+/* $OpenBSD: p_seal.c,v 1.16 2023/07/07 19:37:54 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.18 2023/07/07 13:54:46 beck Exp $ */
+/* $OpenBSD: p_sign.c,v 1.19 2023/07/07 19:37:54 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.17 2023/07/07 13:54:46 beck Exp $ */
+/* $OpenBSD: p_verify.c,v 1.18 2023/07/07 19:37:54 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.8 2023/07/07 13:54:46 beck Exp $ */
+/* $OpenBSD: pmeth_fn.c,v 1.9 2023/07/07 19:37:54 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.12 2023/07/07 13:54:46 beck Exp $ */
+/* $OpenBSD: pmeth_gn.c,v 1.13 2023/07/07 19:37:54 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.32 2023/07/07 13:54:46 beck Exp $ */
+/* $OpenBSD: pmeth_lib.c,v 1.33 2023/07/07 19:37:54 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: asn1.h,v 1.1 2023/07/05 21:23:37 beck Exp $ */
+/* $OpenBSD: asn1.h,v 1.2 2023/07/07 19:37:54 beck Exp $ */
/*
* Copyright (c) 2023 Bob Beck <beck@openbsd.org>
*
LCRYPTO_USED(ASN1_UTCTIME_set);
LCRYPTO_USED(ASN1_UTCTIME_adj);
LCRYPTO_USED(ASN1_UTCTIME_set_string);
-LCRYPTO_USED(ASN1_UTCTIME_cmp_time_t);
LCRYPTO_USED(ASN1_GENERALIZEDTIME_check);
LCRYPTO_USED(ASN1_GENERALIZEDTIME_set);
LCRYPTO_USED(ASN1_GENERALIZEDTIME_adj);
LCRYPTO_USED(ASN1_put_eoc);
LCRYPTO_USED(ASN1_object_size);
LCRYPTO_USED(ASN1_item_dup);
-LCRYPTO_USED(ASN1_dup);
LCRYPTO_USED(ASN1_d2i_fp);
LCRYPTO_USED(ASN1_item_d2i_fp);
LCRYPTO_USED(ASN1_i2d_fp);
-/* $OpenBSD: asn1t.h,v 1.1 2023/07/05 21:23:37 beck Exp $ */
+/* $OpenBSD: asn1t.h,v 1.2 2023/07/07 19:37:54 beck Exp $ */
/*
* Copyright (c) 2023 Bob Beck <beck@openbsd.org>
*
-/* $OpenBSD: bio.h,v 1.1 2023/07/05 21:23:37 beck Exp $ */
+/* $OpenBSD: bio.h,v 1.2 2023/07/07 19:37:54 beck Exp $ */
/*
* Copyright (c) 2023 Bob Beck <beck@openbsd.org>
*
-/* $OpenBSD: chacha.h,v 1.2 2023/07/05 21:14:54 bcook Exp $ */
+/* $OpenBSD: chacha.h,v 1.3 2023/07/07 19:37:54 beck Exp $ */
/*
* Copyright (c) 2023 Bob Beck <beck@openbsd.org>
*
-/* $OpenBSD: ec.h,v 1.1 2023/07/07 13:53:52 beck Exp $ */
+/* $OpenBSD: ec.h,v 1.2 2023/07/07 19:37:54 beck Exp $ */
/*
* Copyright (c) 2023 Bob Beck <beck@openbsd.org>
*
LCRYPTO_USED(EC_GFp_mont_method);
LCRYPTO_USED(EC_GROUP_new);
LCRYPTO_USED(EC_GROUP_free);
-LCRYPTO_USED(EC_GROUP_clear_free);
LCRYPTO_USED(EC_GROUP_copy);
LCRYPTO_USED(EC_GROUP_dup);
LCRYPTO_USED(EC_GROUP_method_of);
LCRYPTO_USED(EC_GROUP_set_seed);
LCRYPTO_USED(EC_GROUP_set_curve);
LCRYPTO_USED(EC_GROUP_get_curve);
-LCRYPTO_USED(EC_GROUP_set_curve_GFp);
-LCRYPTO_USED(EC_GROUP_get_curve_GFp);
LCRYPTO_USED(EC_GROUP_get_degree);
LCRYPTO_USED(EC_GROUP_check);
LCRYPTO_USED(EC_GROUP_check_discriminant);
LCRYPTO_USED(EC_curve_nist2nid);
LCRYPTO_USED(EC_POINT_new);
LCRYPTO_USED(EC_POINT_free);
-LCRYPTO_USED(EC_POINT_clear_free);
LCRYPTO_USED(EC_POINT_copy);
LCRYPTO_USED(EC_POINT_dup);
LCRYPTO_USED(EC_POINT_method_of);
LCRYPTO_USED(EC_POINT_set_affine_coordinates);
LCRYPTO_USED(EC_POINT_get_affine_coordinates);
LCRYPTO_USED(EC_POINT_set_compressed_coordinates);
-LCRYPTO_USED(EC_POINT_set_Jprojective_coordinates_GFp);
-LCRYPTO_USED(EC_POINT_get_Jprojective_coordinates_GFp);
-LCRYPTO_USED(EC_POINT_set_affine_coordinates_GFp);
-LCRYPTO_USED(EC_POINT_get_affine_coordinates_GFp);
-LCRYPTO_USED(EC_POINT_set_compressed_coordinates_GFp);
LCRYPTO_USED(EC_POINT_point2oct);
LCRYPTO_USED(EC_POINT_oct2point);
LCRYPTO_USED(EC_POINT_point2bn);
-/* $OpenBSD: ecdsa.h,v 1.1 2023/07/07 13:53:52 beck Exp $ */
+/* $OpenBSD: ecdsa.h,v 1.2 2023/07/07 19:37:54 beck Exp $ */
/*
* Copyright (c) 2023 Bob Beck <beck@openbsd.org>
*
-/* $OpenBSD: err.h,v 1.1 2023/07/07 13:53:52 beck Exp $ */
+/* $OpenBSD: err.h,v 1.2 2023/07/07 19:37:54 beck Exp $ */
/*
* Copyright (c) 2023 Bob Beck <beck@openbsd.org>
*
LCRYPTO_USED(ERR_print_errors_fp);
LCRYPTO_USED(ERR_print_errors);
LCRYPTO_USED(ERR_asprintf_error_data);
-LCRYPTO_USED(ERR_add_error_data);
-LCRYPTO_USED(ERR_add_error_vdata);
LCRYPTO_USED(ERR_load_strings);
LCRYPTO_USED(ERR_unload_strings);
LCRYPTO_USED(ERR_load_ERR_strings);
+++ /dev/null
-/* $OpenBSD: evp.h,v 1.1 2023/07/07 13:53:52 beck Exp $ */
-/*
- * Copyright (c) 2023 Bob Beck <beck@openbsd.org>
- *
- * Permission to use, copy, modify, and distribute this software for any
- * purpose with or without fee is hereby granted, provided that the above
- * copyright notice and this permission notice appear in all copies.
- *
- * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
- * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
- * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
- * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
- * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
- * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
- * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
- */
-
-#ifndef _LIBCRYPTO_EVP_H
-#define _LIBCRYPTO_EVP_H
-
-#ifndef _MSC_VER
-#include_next <openssl/evp.h>
-#else
-#include "../include/openssl/evp.h"
-#endif
-#include "crypto_namespace.h"
-
-LCRYPTO_USED(EVP_MD_type);
-LCRYPTO_USED(EVP_MD_pkey_type);
-LCRYPTO_USED(EVP_MD_size);
-LCRYPTO_USED(EVP_MD_block_size);
-LCRYPTO_USED(EVP_MD_flags);
-LCRYPTO_USED(EVP_MD_meth_new);
-LCRYPTO_USED(EVP_MD_meth_free);
-LCRYPTO_USED(EVP_MD_meth_dup);
-LCRYPTO_USED(EVP_MD_meth_set_input_blocksize);
-LCRYPTO_USED(EVP_MD_meth_set_result_size);
-LCRYPTO_USED(EVP_MD_meth_set_app_datasize);
-LCRYPTO_USED(EVP_MD_meth_set_flags);
-LCRYPTO_USED(EVP_MD_meth_set_init);
-LCRYPTO_USED(EVP_MD_meth_set_update);
-LCRYPTO_USED(EVP_MD_meth_set_final);
-LCRYPTO_USED(EVP_MD_meth_set_copy);
-LCRYPTO_USED(EVP_MD_meth_set_cleanup);
-LCRYPTO_USED(EVP_MD_meth_set_ctrl);
-LCRYPTO_USED(EVP_MD_CTX_md);
-LCRYPTO_USED(EVP_MD_CTX_md_data);
-LCRYPTO_USED(EVP_MD_CTX_pkey_ctx);
-LCRYPTO_USED(EVP_MD_CTX_set_pkey_ctx);
-LCRYPTO_USED(EVP_CIPHER_nid);
-LCRYPTO_USED(EVP_CIPHER_block_size);
-LCRYPTO_USED(EVP_CIPHER_key_length);
-LCRYPTO_USED(EVP_CIPHER_iv_length);
-LCRYPTO_USED(EVP_CIPHER_flags);
-LCRYPTO_USED(EVP_CIPHER_CTX_cipher);
-LCRYPTO_USED(EVP_CIPHER_CTX_encrypting);
-LCRYPTO_USED(EVP_CIPHER_CTX_nid);
-LCRYPTO_USED(EVP_CIPHER_CTX_block_size);
-LCRYPTO_USED(EVP_CIPHER_CTX_key_length);
-LCRYPTO_USED(EVP_CIPHER_CTX_iv_length);
-LCRYPTO_USED(EVP_CIPHER_CTX_get_iv);
-LCRYPTO_USED(EVP_CIPHER_CTX_set_iv);
-LCRYPTO_USED(EVP_CIPHER_CTX_copy);
-LCRYPTO_USED(EVP_CIPHER_CTX_get_app_data);
-LCRYPTO_USED(EVP_CIPHER_CTX_set_app_data);
-LCRYPTO_USED(EVP_CIPHER_CTX_get_cipher_data);
-LCRYPTO_USED(EVP_CIPHER_CTX_set_cipher_data);
-LCRYPTO_USED(EVP_CIPHER_CTX_buf_noconst);
-LCRYPTO_USED(EVP_CIPHER_CTX_flags);
-LCRYPTO_USED(EVP_CIPHER_meth_new);
-LCRYPTO_USED(EVP_CIPHER_meth_dup);
-LCRYPTO_USED(EVP_CIPHER_meth_free);
-LCRYPTO_USED(EVP_CIPHER_meth_set_iv_length);
-LCRYPTO_USED(EVP_CIPHER_meth_set_flags);
-LCRYPTO_USED(EVP_CIPHER_meth_set_impl_ctx_size);
-LCRYPTO_USED(EVP_CIPHER_meth_set_init);
-LCRYPTO_USED(EVP_CIPHER_meth_set_do_cipher);
-LCRYPTO_USED(EVP_CIPHER_meth_set_cleanup);
-LCRYPTO_USED(EVP_CIPHER_meth_set_set_asn1_params);
-LCRYPTO_USED(EVP_CIPHER_meth_set_get_asn1_params);
-LCRYPTO_USED(EVP_CIPHER_meth_set_ctrl);
-LCRYPTO_USED(EVP_PKEY_new_raw_private_key);
-LCRYPTO_USED(EVP_PKEY_new_raw_public_key);
-LCRYPTO_USED(EVP_PKEY_get_raw_private_key);
-LCRYPTO_USED(EVP_PKEY_get_raw_public_key);
-LCRYPTO_USED(EVP_Cipher);
-LCRYPTO_USED(EVP_MD_CTX_new);
-LCRYPTO_USED(EVP_MD_CTX_free);
-LCRYPTO_USED(EVP_MD_CTX_init);
-LCRYPTO_USED(EVP_MD_CTX_reset);
-LCRYPTO_USED(EVP_MD_CTX_create);
-LCRYPTO_USED(EVP_MD_CTX_destroy);
-LCRYPTO_USED(EVP_MD_CTX_cleanup);
-LCRYPTO_USED(EVP_MD_CTX_copy_ex);
-LCRYPTO_USED(EVP_MD_CTX_set_flags);
-LCRYPTO_USED(EVP_MD_CTX_clear_flags);
-LCRYPTO_USED(EVP_MD_CTX_ctrl);
-LCRYPTO_USED(EVP_MD_CTX_test_flags);
-LCRYPTO_USED(EVP_DigestInit_ex);
-LCRYPTO_USED(EVP_DigestUpdate);
-LCRYPTO_USED(EVP_DigestFinal_ex);
-LCRYPTO_USED(EVP_Digest);
-LCRYPTO_USED(EVP_MD_CTX_copy);
-LCRYPTO_USED(EVP_DigestInit);
-LCRYPTO_USED(EVP_DigestFinal);
-LCRYPTO_USED(EVP_read_pw_string);
-LCRYPTO_USED(EVP_read_pw_string_min);
-LCRYPTO_USED(EVP_set_pw_prompt);
-LCRYPTO_USED(EVP_get_pw_prompt);
-LCRYPTO_USED(EVP_BytesToKey);
-LCRYPTO_USED(EVP_CIPHER_CTX_set_flags);
-LCRYPTO_USED(EVP_CIPHER_CTX_clear_flags);
-LCRYPTO_USED(EVP_CIPHER_CTX_test_flags);
-LCRYPTO_USED(EVP_EncryptInit);
-LCRYPTO_USED(EVP_EncryptInit_ex);
-LCRYPTO_USED(EVP_EncryptUpdate);
-LCRYPTO_USED(EVP_EncryptFinal_ex);
-LCRYPTO_USED(EVP_EncryptFinal);
-LCRYPTO_USED(EVP_DecryptInit);
-LCRYPTO_USED(EVP_DecryptInit_ex);
-LCRYPTO_USED(EVP_DecryptUpdate);
-LCRYPTO_USED(EVP_DecryptFinal_ex);
-LCRYPTO_USED(EVP_DecryptFinal);
-LCRYPTO_USED(EVP_CipherInit);
-LCRYPTO_USED(EVP_CipherInit_ex);
-LCRYPTO_USED(EVP_CipherUpdate);
-LCRYPTO_USED(EVP_CipherFinal_ex);
-LCRYPTO_USED(EVP_CipherFinal);
-LCRYPTO_USED(EVP_SignFinal);
-LCRYPTO_USED(EVP_VerifyFinal);
-LCRYPTO_USED(EVP_DigestSignInit);
-LCRYPTO_USED(EVP_DigestSignFinal);
-LCRYPTO_USED(EVP_DigestSign);
-LCRYPTO_USED(EVP_DigestVerifyInit);
-LCRYPTO_USED(EVP_DigestVerifyFinal);
-LCRYPTO_USED(EVP_DigestVerify);
-LCRYPTO_USED(EVP_OpenInit);
-LCRYPTO_USED(EVP_OpenFinal);
-LCRYPTO_USED(EVP_SealInit);
-LCRYPTO_USED(EVP_SealFinal);
-LCRYPTO_USED(EVP_ENCODE_CTX_new);
-LCRYPTO_USED(EVP_ENCODE_CTX_free);
-LCRYPTO_USED(EVP_EncodeInit);
-LCRYPTO_USED(EVP_EncodeUpdate);
-LCRYPTO_USED(EVP_EncodeFinal);
-LCRYPTO_USED(EVP_EncodeBlock);
-LCRYPTO_USED(EVP_DecodeInit);
-LCRYPTO_USED(EVP_DecodeUpdate);
-LCRYPTO_USED(EVP_DecodeFinal);
-LCRYPTO_USED(EVP_DecodeBlock);
-LCRYPTO_USED(EVP_CIPHER_CTX_init);
-LCRYPTO_USED(EVP_CIPHER_CTX_cleanup);
-LCRYPTO_USED(EVP_CIPHER_CTX_new);
-LCRYPTO_USED(EVP_CIPHER_CTX_free);
-LCRYPTO_USED(EVP_CIPHER_CTX_reset);
-LCRYPTO_USED(EVP_CIPHER_CTX_set_key_length);
-LCRYPTO_USED(EVP_CIPHER_CTX_set_padding);
-LCRYPTO_USED(EVP_CIPHER_CTX_ctrl);
-LCRYPTO_USED(EVP_CIPHER_CTX_rand_key);
-LCRYPTO_USED(BIO_f_md);
-LCRYPTO_USED(BIO_f_base64);
-LCRYPTO_USED(BIO_f_cipher);
-LCRYPTO_USED(BIO_set_cipher);
-LCRYPTO_USED(EVP_md_null);
-LCRYPTO_USED(EVP_md4);
-LCRYPTO_USED(EVP_md5);
-LCRYPTO_USED(EVP_md5_sha1);
-LCRYPTO_USED(EVP_sha1);
-LCRYPTO_USED(EVP_sha224);
-LCRYPTO_USED(EVP_sha256);
-LCRYPTO_USED(EVP_sha384);
-LCRYPTO_USED(EVP_sha512);
-LCRYPTO_USED(EVP_sha512_224);
-LCRYPTO_USED(EVP_sha512_256);
-LCRYPTO_USED(EVP_sha3_224);
-LCRYPTO_USED(EVP_sha3_256);
-LCRYPTO_USED(EVP_sha3_384);
-LCRYPTO_USED(EVP_sha3_512);
-LCRYPTO_USED(EVP_sm3);
-LCRYPTO_USED(EVP_ripemd160);
-LCRYPTO_USED(EVP_whirlpool);
-LCRYPTO_USED(EVP_gostr341194);
-LCRYPTO_USED(EVP_gost2814789imit);
-LCRYPTO_USED(EVP_streebog256);
-LCRYPTO_USED(EVP_streebog512);
-LCRYPTO_USED(EVP_enc_null);
-LCRYPTO_USED(EVP_des_ecb);
-LCRYPTO_USED(EVP_des_ede);
-LCRYPTO_USED(EVP_des_ede3);
-LCRYPTO_USED(EVP_des_ede_ecb);
-LCRYPTO_USED(EVP_des_ede3_ecb);
-LCRYPTO_USED(EVP_des_cfb64);
-LCRYPTO_USED(EVP_des_cfb1);
-LCRYPTO_USED(EVP_des_cfb8);
-LCRYPTO_USED(EVP_des_ede_cfb64);
-LCRYPTO_USED(EVP_des_ede3_cfb64);
-LCRYPTO_USED(EVP_des_ede3_cfb1);
-LCRYPTO_USED(EVP_des_ede3_cfb8);
-LCRYPTO_USED(EVP_des_ofb);
-LCRYPTO_USED(EVP_des_ede_ofb);
-LCRYPTO_USED(EVP_des_ede3_ofb);
-LCRYPTO_USED(EVP_des_cbc);
-LCRYPTO_USED(EVP_des_ede_cbc);
-LCRYPTO_USED(EVP_des_ede3_cbc);
-LCRYPTO_USED(EVP_desx_cbc);
-LCRYPTO_USED(EVP_rc4);
-LCRYPTO_USED(EVP_rc4_40);
-LCRYPTO_USED(EVP_rc4_hmac_md5);
-LCRYPTO_USED(EVP_idea_ecb);
-LCRYPTO_USED(EVP_idea_cfb64);
-LCRYPTO_USED(EVP_idea_ofb);
-LCRYPTO_USED(EVP_idea_cbc);
-LCRYPTO_USED(EVP_rc2_ecb);
-LCRYPTO_USED(EVP_rc2_cbc);
-LCRYPTO_USED(EVP_rc2_40_cbc);
-LCRYPTO_USED(EVP_rc2_64_cbc);
-LCRYPTO_USED(EVP_rc2_cfb64);
-LCRYPTO_USED(EVP_rc2_ofb);
-LCRYPTO_USED(EVP_bf_ecb);
-LCRYPTO_USED(EVP_bf_cbc);
-LCRYPTO_USED(EVP_bf_cfb64);
-LCRYPTO_USED(EVP_bf_ofb);
-LCRYPTO_USED(EVP_cast5_ecb);
-LCRYPTO_USED(EVP_cast5_cbc);
-LCRYPTO_USED(EVP_cast5_cfb64);
-LCRYPTO_USED(EVP_cast5_ofb);
-LCRYPTO_USED(EVP_aes_128_ecb);
-LCRYPTO_USED(EVP_aes_128_cbc);
-LCRYPTO_USED(EVP_aes_128_cfb1);
-LCRYPTO_USED(EVP_aes_128_cfb8);
-LCRYPTO_USED(EVP_aes_128_cfb128);
-LCRYPTO_USED(EVP_aes_128_ofb);
-LCRYPTO_USED(EVP_aes_128_ctr);
-LCRYPTO_USED(EVP_aes_128_ccm);
-LCRYPTO_USED(EVP_aes_128_gcm);
-LCRYPTO_USED(EVP_aes_128_wrap);
-LCRYPTO_USED(EVP_aes_128_xts);
-LCRYPTO_USED(EVP_aes_192_ecb);
-LCRYPTO_USED(EVP_aes_192_cbc);
-LCRYPTO_USED(EVP_aes_192_cfb1);
-LCRYPTO_USED(EVP_aes_192_cfb8);
-LCRYPTO_USED(EVP_aes_192_cfb128);
-LCRYPTO_USED(EVP_aes_192_ofb);
-LCRYPTO_USED(EVP_aes_192_ctr);
-LCRYPTO_USED(EVP_aes_192_ccm);
-LCRYPTO_USED(EVP_aes_192_gcm);
-LCRYPTO_USED(EVP_aes_192_wrap);
-LCRYPTO_USED(EVP_aes_256_ecb);
-LCRYPTO_USED(EVP_aes_256_cbc);
-LCRYPTO_USED(EVP_aes_256_cfb1);
-LCRYPTO_USED(EVP_aes_256_cfb8);
-LCRYPTO_USED(EVP_aes_256_cfb128);
-LCRYPTO_USED(EVP_aes_256_ofb);
-LCRYPTO_USED(EVP_aes_256_ctr);
-LCRYPTO_USED(EVP_aes_256_ccm);
-LCRYPTO_USED(EVP_aes_256_gcm);
-LCRYPTO_USED(EVP_aes_256_wrap);
-LCRYPTO_USED(EVP_aes_256_xts);
-LCRYPTO_USED(EVP_chacha20_poly1305);
-LCRYPTO_USED(EVP_aes_128_cbc_hmac_sha1);
-LCRYPTO_USED(EVP_aes_256_cbc_hmac_sha1);
-LCRYPTO_USED(EVP_camellia_128_ecb);
-LCRYPTO_USED(EVP_camellia_128_cbc);
-LCRYPTO_USED(EVP_camellia_128_cfb1);
-LCRYPTO_USED(EVP_camellia_128_cfb8);
-LCRYPTO_USED(EVP_camellia_128_cfb128);
-LCRYPTO_USED(EVP_camellia_128_ofb);
-LCRYPTO_USED(EVP_camellia_192_ecb);
-LCRYPTO_USED(EVP_camellia_192_cbc);
-LCRYPTO_USED(EVP_camellia_192_cfb1);
-LCRYPTO_USED(EVP_camellia_192_cfb8);
-LCRYPTO_USED(EVP_camellia_192_cfb128);
-LCRYPTO_USED(EVP_camellia_192_ofb);
-LCRYPTO_USED(EVP_camellia_256_ecb);
-LCRYPTO_USED(EVP_camellia_256_cbc);
-LCRYPTO_USED(EVP_camellia_256_cfb1);
-LCRYPTO_USED(EVP_camellia_256_cfb8);
-LCRYPTO_USED(EVP_camellia_256_cfb128);
-LCRYPTO_USED(EVP_camellia_256_ofb);
-LCRYPTO_USED(EVP_chacha20);
-LCRYPTO_USED(EVP_gost2814789_ecb);
-LCRYPTO_USED(EVP_gost2814789_cfb64);
-LCRYPTO_USED(EVP_gost2814789_cnt);
-LCRYPTO_USED(EVP_sm4_ecb);
-LCRYPTO_USED(EVP_sm4_cbc);
-LCRYPTO_USED(EVP_sm4_cfb128);
-LCRYPTO_USED(EVP_sm4_ofb);
-LCRYPTO_USED(EVP_sm4_ctr);
-LCRYPTO_USED(OPENSSL_add_all_algorithms_noconf);
-LCRYPTO_USED(OPENSSL_add_all_algorithms_conf);
-LCRYPTO_USED(OpenSSL_add_all_ciphers);
-LCRYPTO_USED(OpenSSL_add_all_digests);
-LCRYPTO_USED(EVP_add_cipher);
-LCRYPTO_USED(EVP_add_digest);
-LCRYPTO_USED(EVP_get_cipherbyname);
-LCRYPTO_USED(EVP_get_digestbyname);
-LCRYPTO_USED(EVP_cleanup);
-LCRYPTO_USED(EVP_CIPHER_do_all);
-LCRYPTO_USED(EVP_CIPHER_do_all_sorted);
-LCRYPTO_USED(EVP_MD_do_all);
-LCRYPTO_USED(EVP_MD_do_all_sorted);
-LCRYPTO_USED(EVP_PKEY_decrypt_old);
-LCRYPTO_USED(EVP_PKEY_encrypt_old);
-LCRYPTO_USED(EVP_PKEY_type);
-LCRYPTO_USED(EVP_PKEY_id);
-LCRYPTO_USED(EVP_PKEY_base_id);
-LCRYPTO_USED(EVP_PKEY_bits);
-LCRYPTO_USED(EVP_PKEY_security_bits);
-LCRYPTO_USED(EVP_PKEY_size);
-LCRYPTO_USED(EVP_PKEY_set_type);
-LCRYPTO_USED(EVP_PKEY_set_type_str);
-LCRYPTO_USED(EVP_PKEY_assign);
-LCRYPTO_USED(EVP_PKEY_get0);
-LCRYPTO_USED(EVP_PKEY_get0_hmac);
-LCRYPTO_USED(EVP_PKEY_get0_RSA);
-LCRYPTO_USED(EVP_PKEY_get1_RSA);
-LCRYPTO_USED(EVP_PKEY_set1_RSA);
-LCRYPTO_USED(EVP_PKEY_get0_DSA);
-LCRYPTO_USED(EVP_PKEY_get1_DSA);
-LCRYPTO_USED(EVP_PKEY_set1_DSA);
-LCRYPTO_USED(EVP_PKEY_get0_DH);
-LCRYPTO_USED(EVP_PKEY_get1_DH);
-LCRYPTO_USED(EVP_PKEY_set1_DH);
-LCRYPTO_USED(EVP_PKEY_get0_EC_KEY);
-LCRYPTO_USED(EVP_PKEY_get1_EC_KEY);
-LCRYPTO_USED(EVP_PKEY_set1_EC_KEY);
-LCRYPTO_USED(EVP_PKEY_new);
-LCRYPTO_USED(EVP_PKEY_free);
-LCRYPTO_USED(EVP_PKEY_up_ref);
-LCRYPTO_USED(d2i_PublicKey);
-LCRYPTO_USED(i2d_PublicKey);
-LCRYPTO_USED(d2i_PrivateKey);
-LCRYPTO_USED(d2i_AutoPrivateKey);
-LCRYPTO_USED(i2d_PrivateKey);
-LCRYPTO_USED(EVP_PKEY_copy_parameters);
-LCRYPTO_USED(EVP_PKEY_missing_parameters);
-LCRYPTO_USED(EVP_PKEY_save_parameters);
-LCRYPTO_USED(EVP_PKEY_cmp_parameters);
-LCRYPTO_USED(EVP_PKEY_cmp);
-LCRYPTO_USED(EVP_PKEY_print_public);
-LCRYPTO_USED(EVP_PKEY_print_private);
-LCRYPTO_USED(EVP_PKEY_print_params);
-LCRYPTO_USED(EVP_PKEY_get_default_digest_nid);
-LCRYPTO_USED(EVP_CIPHER_type);
-LCRYPTO_USED(EVP_CIPHER_param_to_asn1);
-LCRYPTO_USED(EVP_CIPHER_asn1_to_param);
-LCRYPTO_USED(EVP_CIPHER_set_asn1_iv);
-LCRYPTO_USED(EVP_CIPHER_get_asn1_iv);
-LCRYPTO_USED(PKCS5_PBE_keyivgen);
-LCRYPTO_USED(PKCS5_PBKDF2_HMAC_SHA1);
-LCRYPTO_USED(PKCS5_PBKDF2_HMAC);
-LCRYPTO_USED(PKCS5_v2_PBE_keyivgen);
-LCRYPTO_USED(PKCS5_PBE_add);
-LCRYPTO_USED(EVP_PBE_CipherInit);
-LCRYPTO_USED(EVP_PBE_alg_add_type);
-LCRYPTO_USED(EVP_PBE_alg_add);
-LCRYPTO_USED(EVP_PBE_find);
-LCRYPTO_USED(EVP_PBE_cleanup);
-LCRYPTO_USED(EVP_PKEY_asn1_get_count);
-LCRYPTO_USED(EVP_PKEY_asn1_get0);
-LCRYPTO_USED(EVP_PKEY_asn1_find);
-LCRYPTO_USED(EVP_PKEY_asn1_find_str);
-LCRYPTO_USED(EVP_PKEY_asn1_add0);
-LCRYPTO_USED(EVP_PKEY_asn1_add_alias);
-LCRYPTO_USED(EVP_PKEY_asn1_get0_info);
-LCRYPTO_USED(EVP_PKEY_get0_asn1);
-LCRYPTO_USED(EVP_PKEY_asn1_new);
-LCRYPTO_USED(EVP_PKEY_asn1_copy);
-LCRYPTO_USED(EVP_PKEY_asn1_free);
-LCRYPTO_USED(EVP_PKEY_asn1_set_public);
-LCRYPTO_USED(EVP_PKEY_asn1_set_private);
-LCRYPTO_USED(EVP_PKEY_asn1_set_param);
-LCRYPTO_USED(EVP_PKEY_asn1_set_free);
-LCRYPTO_USED(EVP_PKEY_asn1_set_ctrl);
-LCRYPTO_USED(EVP_PKEY_asn1_set_security_bits);
-LCRYPTO_USED(EVP_PKEY_asn1_set_check);
-LCRYPTO_USED(EVP_PKEY_asn1_set_public_check);
-LCRYPTO_USED(EVP_PKEY_asn1_set_param_check);
-LCRYPTO_USED(EVP_PKEY_meth_find);
-LCRYPTO_USED(EVP_PKEY_meth_new);
-LCRYPTO_USED(EVP_PKEY_meth_get0_info);
-LCRYPTO_USED(EVP_PKEY_meth_copy);
-LCRYPTO_USED(EVP_PKEY_meth_free);
-LCRYPTO_USED(EVP_PKEY_meth_add0);
-LCRYPTO_USED(EVP_PKEY_CTX_new);
-LCRYPTO_USED(EVP_PKEY_CTX_new_id);
-LCRYPTO_USED(EVP_PKEY_CTX_dup);
-LCRYPTO_USED(EVP_PKEY_CTX_free);
-LCRYPTO_USED(EVP_PKEY_CTX_ctrl);
-LCRYPTO_USED(EVP_PKEY_CTX_ctrl_str);
-LCRYPTO_USED(EVP_PKEY_CTX_get_operation);
-LCRYPTO_USED(EVP_PKEY_CTX_set0_keygen_info);
-LCRYPTO_USED(EVP_PKEY_new_mac_key);
-LCRYPTO_USED(EVP_PKEY_new_CMAC_key);
-LCRYPTO_USED(EVP_PKEY_CTX_set_data);
-LCRYPTO_USED(EVP_PKEY_CTX_get_data);
-LCRYPTO_USED(EVP_PKEY_CTX_get0_pkey);
-LCRYPTO_USED(EVP_PKEY_CTX_get0_peerkey);
-LCRYPTO_USED(EVP_PKEY_CTX_set_app_data);
-LCRYPTO_USED(EVP_PKEY_CTX_get_app_data);
-LCRYPTO_USED(EVP_PKEY_sign_init);
-LCRYPTO_USED(EVP_PKEY_sign);
-LCRYPTO_USED(EVP_PKEY_verify_init);
-LCRYPTO_USED(EVP_PKEY_verify);
-LCRYPTO_USED(EVP_PKEY_verify_recover_init);
-LCRYPTO_USED(EVP_PKEY_verify_recover);
-LCRYPTO_USED(EVP_PKEY_encrypt_init);
-LCRYPTO_USED(EVP_PKEY_encrypt);
-LCRYPTO_USED(EVP_PKEY_decrypt_init);
-LCRYPTO_USED(EVP_PKEY_decrypt);
-LCRYPTO_USED(EVP_PKEY_derive_init);
-LCRYPTO_USED(EVP_PKEY_derive_set_peer);
-LCRYPTO_USED(EVP_PKEY_derive);
-LCRYPTO_USED(EVP_PKEY_paramgen_init);
-LCRYPTO_USED(EVP_PKEY_paramgen);
-LCRYPTO_USED(EVP_PKEY_keygen_init);
-LCRYPTO_USED(EVP_PKEY_keygen);
-LCRYPTO_USED(EVP_PKEY_check);
-LCRYPTO_USED(EVP_PKEY_public_check);
-LCRYPTO_USED(EVP_PKEY_param_check);
-LCRYPTO_USED(EVP_PKEY_CTX_set_cb);
-LCRYPTO_USED(EVP_PKEY_CTX_get_cb);
-LCRYPTO_USED(EVP_PKEY_CTX_get_keygen_info);
-LCRYPTO_USED(EVP_PKEY_meth_set_init);
-LCRYPTO_USED(EVP_PKEY_meth_set_copy);
-LCRYPTO_USED(EVP_PKEY_meth_set_cleanup);
-LCRYPTO_USED(EVP_PKEY_meth_set_paramgen);
-LCRYPTO_USED(EVP_PKEY_meth_set_keygen);
-LCRYPTO_USED(EVP_PKEY_meth_set_sign);
-LCRYPTO_USED(EVP_PKEY_meth_set_verify);
-LCRYPTO_USED(EVP_PKEY_meth_set_verify_recover);
-LCRYPTO_USED(EVP_PKEY_meth_set_signctx);
-LCRYPTO_USED(EVP_PKEY_meth_set_verifyctx);
-LCRYPTO_USED(EVP_PKEY_meth_set_encrypt);
-LCRYPTO_USED(EVP_PKEY_meth_set_decrypt);
-LCRYPTO_USED(EVP_PKEY_meth_set_derive);
-LCRYPTO_USED(EVP_PKEY_meth_set_ctrl);
-LCRYPTO_USED(EVP_PKEY_meth_set_check);
-LCRYPTO_USED(EVP_PKEY_meth_set_public_check);
-LCRYPTO_USED(EVP_PKEY_meth_set_param_check);
-LCRYPTO_USED(EVP_aead_aes_128_gcm);
-LCRYPTO_USED(EVP_aead_aes_256_gcm);
-LCRYPTO_USED(EVP_aead_chacha20_poly1305);
-LCRYPTO_USED(EVP_aead_xchacha20_poly1305);
-LCRYPTO_USED(EVP_AEAD_key_length);
-LCRYPTO_USED(EVP_AEAD_nonce_length);
-LCRYPTO_USED(EVP_AEAD_max_overhead);
-LCRYPTO_USED(EVP_AEAD_max_tag_len);
-LCRYPTO_USED(EVP_AEAD_CTX_new);
-LCRYPTO_USED(EVP_AEAD_CTX_free);
-LCRYPTO_USED(EVP_AEAD_CTX_init);
-LCRYPTO_USED(EVP_AEAD_CTX_cleanup);
-LCRYPTO_USED(EVP_AEAD_CTX_seal);
-LCRYPTO_USED(EVP_AEAD_CTX_open);
-LCRYPTO_USED(ERR_load_EVP_strings);
-
-#endif /* _LIBCRYPTO_EVP_H */
-/* $OpenBSD: hkdf.h,v 1.1 2023/07/07 13:53:52 beck Exp $ */
+/* $OpenBSD: hkdf.h,v 1.2 2023/07/07 19:37:54 beck Exp $ */
/*
* Copyright (c) 2023 Bob Beck <beck@openbsd.org>
*
-/* $OpenBSD: lhash.h,v 1.1 2023/07/07 13:40:44 beck Exp $ */
+/* $OpenBSD: lhash.h,v 1.2 2023/07/07 19:37:54 beck Exp $ */
/*
* Copyright (c) 2023 Bob Beck <beck@openbsd.org>
*
-/* $OpenBSD: pem.h,v 1.1 2023/07/07 13:40:44 beck Exp $ */
+/* $OpenBSD: pem.h,v 1.2 2023/07/07 19:37:54 beck Exp $ */
/*
* Copyright (c) 2023 Bob Beck <beck@openbsd.org>
*
-/* $OpenBSD: poly1305.h,v 1.1 2023/07/07 12:01:32 beck Exp $ */
+/* $OpenBSD: poly1305.h,v 1.2 2023/07/07 19:37:54 beck Exp $ */
/*
* Copyright (c) 2023 Bob Beck <beck@openbsd.org>
*
-/* $OpenBSD: rand.h,v 1.1 2023/07/07 12:01:32 beck Exp $ */
+/* $OpenBSD: rand.h,v 1.2 2023/07/07 19:37:54 beck Exp $ */
/*
* Copyright (c) 2023 Bob Beck <beck@openbsd.org>
*
LCRYPTO_USED(RAND_get_rand_method);
LCRYPTO_USED(RAND_set_rand_engine);
LCRYPTO_USED(RAND_SSLeay);
-LCRYPTO_USED(RAND_cleanup);
-LCRYPTO_USED(RAND_bytes);
-LCRYPTO_USED(RAND_pseudo_bytes);
-LCRYPTO_USED(RAND_seed);
-LCRYPTO_USED(RAND_add);
-LCRYPTO_USED(RAND_load_file);
-LCRYPTO_USED(RAND_write_file);
-LCRYPTO_USED(RAND_file_name);
-LCRYPTO_USED(RAND_status);
-LCRYPTO_USED(RAND_poll);
LCRYPTO_USED(ERR_load_RAND_strings);
#endif /* _LIBCRYPTO_RAND_H */
+++ /dev/null
-/* $OpenBSD: sm3.h,v 1.1 2023/07/07 12:01:32 beck Exp $ */
-/*
- * Copyright (c) 2023 Bob Beck <beck@openbsd.org>
- *
- * Permission to use, copy, modify, and distribute this software for any
- * purpose with or without fee is hereby granted, provided that the above
- * copyright notice and this permission notice appear in all copies.
- *
- * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
- * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
- * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
- * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
- * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
- * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
- * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
- */
-
-#ifndef _LIBCRYPTO_SM3_H
-#define _LIBCRYPTO_SM3_H
-
-#ifndef _MSC_VER
-#include_next <openssl/sm3.h>
-#else
-#include "../include/openssl/sm3.h"
-#endif
-#include "crypto_namespace.h"
-
-LCRYPTO_USED(SM3_Init);
-LCRYPTO_USED(SM3_Update);
-LCRYPTO_USED(SM3_Final);
-
-#endif /* _LIBCRYPTO_SM3_H */
-/* $OpenBSD: sm4.h,v 1.1 2023/07/07 12:01:32 beck Exp $ */
+/* $OpenBSD: sm4.h,v 1.2 2023/07/07 19:37:54 beck Exp $ */
/*
* Copyright (c) 2023 Bob Beck <beck@openbsd.org>
*
-/* $OpenBSD: ts.h,v 1.1 2023/07/07 07:25:21 beck Exp $ */
+/* $OpenBSD: ts.h,v 1.2 2023/07/07 19:37:54 beck Exp $ */
/*
* Copyright (c) 2023 Bob Beck <beck@openbsd.org>
*
-/* $OpenBSD: rand_lib.c,v 1.21 2023/07/07 12:01:32 beck Exp $ */
+/* $OpenBSD: rand_lib.c,v 1.22 2023/07/07 19:37:54 beck Exp $ */
/*
* Copyright (c) 2014 Ted Unangst <tedu@openbsd.org>
*
{
}
-LCRYPTO_ALIAS(RAND_cleanup);
void
RAND_seed(const void *buf, int num)
{
}
-LCRYPTO_ALIAS(RAND_seed);
void
RAND_add(const void *buf, int num, double entropy)
{
}
-LCRYPTO_ALIAS(RAND_add);
int
RAND_status(void)
{
return 1;
}
-LCRYPTO_ALIAS(RAND_status);
int
RAND_poll(void)
{
return 1;
}
-LCRYPTO_ALIAS(RAND_poll);
/*
* Hurray. You've made it to the good parts.
arc4random_buf(buf, num);
return 1;
}
-LCRYPTO_ALIAS(RAND_bytes);
int
RAND_pseudo_bytes(unsigned char *buf, int num)
arc4random_buf(buf, num);
return 1;
}
-LCRYPTO_ALIAS(RAND_pseudo_bytes);
-/* $OpenBSD: randfile.c,v 1.43 2023/07/07 12:01:32 beck Exp $ */
+/* $OpenBSD: randfile.c,v 1.44 2023/07/07 19:37:54 beck Exp $ */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
* All rights reserved.
*
else
return bytes;
}
-LCRYPTO_ALIAS(RAND_load_file);
int
RAND_write_file(const char *file)
explicit_bzero(buf, BUFSIZE);
return ret;
}
-LCRYPTO_ALIAS(RAND_write_file);
const char *
RAND_file_name(char * buf, size_t size)
return (NULL);
return buf;
}
-LCRYPTO_ALIAS(RAND_file_name);
-/* $OpenBSD: sm3.c,v 1.3 2023/07/07 12:01:32 beck Exp $ */
+/* $OpenBSD: sm3.c,v 1.4 2023/07/07 19:37:54 beck Exp $ */
/*
* Copyright (c) 2018, Ribose Inc
*
c->H = SM3_H;
return 1;
}
-LCRYPTO_ALIAS(SM3_Init);
void
SM3_block_data_order(SM3_CTX *ctx, const void *p, size_t num)
-/* $OpenBSD: ts_req_utils.c,v 1.8 2023/07/07 07:25:21 beck Exp $ */
+/* $OpenBSD: ts_req_utils.c,v 1.9 2023/07/07 19:37:54 beck Exp $ */
/* Written by Zoltan Glozik (zglozik@stones.com) for the OpenSSL
* project 2002.
*/
{
return a->extensions;
}
+LCRYPTO_ALIAS(TS_REQ_get_exts);
void
TS_REQ_ext_free(TS_REQ *a)
-/* $OpenBSD: ts_rsp_utils.c,v 1.10 2023/07/07 07:25:21 beck Exp $ */
+/* $OpenBSD: ts_rsp_utils.c,v 1.11 2023/07/07 19:37:54 beck Exp $ */
/* Written by Zoltan Glozik (zglozik@stones.com) for the OpenSSL
* project 2002.
*/
{
return a->extensions;
}
+LCRYPTO_ALIAS(TS_TST_INFO_get_exts);
void
TS_TST_INFO_ext_free(TS_TST_INFO *a)
projects / openbsd / commitdiff