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