_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
--- /dev/null
+/* $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 */
--- /dev/null
+/* $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 */
--- /dev/null
+/* $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 */
-/* $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.
*
{
return &x509_dir_lookup;
}
+LCRYPTO_ALIAS(X509_LOOKUP_hash_dir)
static int
dir_ctrl(X509_LOOKUP *ctx, int cmd, const char *argp, long argl,
-/* $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.
*
{
return &x509_file_lookup;
}
+LCRYPTO_ALIAS(X509_LOOKUP_file)
static int
by_file_ctrl(X509_LOOKUP *ctx, int cmd, const char *argp, long argl,
BIO_free(in);
return ret;
}
+LCRYPTO_ALIAS(X509_load_cert_file)
int
X509_load_crl_file(X509_LOOKUP *ctx, const char *file, int type)
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)
sk_X509_INFO_pop_free(inf, X509_INFO_free);
return count;
}
-
+LCRYPTO_ALIAS(X509_load_cert_crl_file)
-/* $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.
*
{
return (&x509_mem_lookup);
}
+LCRYPTO_ALIAS(X509_LOOKUP_mem)
static int
by_mem_ctrl(X509_LOOKUP *lu, int cmd, const char *buf,
-/* $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.
*/
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)
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)
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)
else
return tree->user_policies;
}
+LCRYPTO_ALIAS(X509_policy_tree_get0_user_policies)
/* X509_POLICY_LEVEL stuff */
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)
}
return sk_X509_POLICY_NODE_value(level->nodes, i);
}
+LCRYPTO_ALIAS(X509_policy_level_get0_node)
/* X509_POLICY_NODE stuff */
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)
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)
return NULL;
return node->parent;
}
+LCRYPTO_ALIAS(X509_policy_node_get0_parent)
-/* $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.
*/
free(tree->levels);
free(tree);
}
+LCRYPTO_ALIAS(X509_policy_tree_free)
/* Application policy checking function.
* Return codes:
return 0;
}
+LCRYPTO_ALIAS(X509_policy_check)
-/* $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").
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)
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)
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)
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.
return afi;
}
+LCRYPTO_ALIAS(X509v3_addr_get_afi)
/*
* Expand the bitstring form (RFC 3779, section 2.1.2) of an address into
return IPAddressFamily_set_inheritance(af);
}
+LCRYPTO_ALIAS(X509v3_addr_add_inherit)
/*
* Construct an IPAddressOrRange sequence, or return an existing one.
return 1;
}
+LCRYPTO_ALIAS(X509v3_addr_add_prefix)
/*
* Add a range.
return 1;
}
+LCRYPTO_ALIAS(X509v3_addr_add_range)
static int
extract_min_max_bitstr(IPAddressOrRange *aor, ASN1_BIT_STRING **out_min,
return afi_len;
}
+LCRYPTO_ALIAS(X509v3_addr_get_range)
/*
* Check whether an IPAddrBLocks is in canonical form.
*/
return 1;
}
+LCRYPTO_ALIAS(X509v3_addr_is_canonical)
/*
* Whack an IPAddressOrRanges into canonical form.
return X509v3_addr_is_canonical(addr);
}
+LCRYPTO_ALIAS(X509v3_addr_canonize)
/*
* v2i handler for the IPAddrBlocks extension.
return 0;
}
+LCRYPTO_ALIAS(X509v3_addr_inherits)
/*
* Figure out whether parent contains child.
}
return 1;
}
+LCRYPTO_ALIAS(X509v3_addr_subset)
static int
verify_error(X509_STORE_CTX *ctx, X509 *cert, int error, int depth)
}
return addr_validate_path_internal(ctx, ctx->chain, NULL);
}
+LCRYPTO_ALIAS(X509v3_addr_validate_path)
/*
* RFC 3779 2.3 path validation of an extension.
return 0;
return addr_validate_path_internal(NULL, chain, ext);
}
+LCRYPTO_ALIAS(X509v3_addr_validate_resource_set)
#endif /* OPENSSL_NO_RFC3779 */
-/* $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.
*/
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)
-/* $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.
*/
return NULL;
}
+LCRYPTO_ALIAS(i2v_GENERAL_NAMES)
STACK_OF(CONF_VALUE) *
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)
}
return 1;
}
+LCRYPTO_ALIAS(GENERAL_NAME_print)
static GENERAL_NAMES *
v2i_issuer_alt(X509V3_EXT_METHOD *method, X509V3_CTX *ctx,
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,
{
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,
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,
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)
-/* $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").
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)
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,
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)
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.
}
return (*choice)->type == ASIdentifierChoice_inherit;
}
+LCRYPTO_ALIAS(X509v3_asid_add_inherit)
/*
* Add an ID or range to an ASIdentifierChoice.
ASIdOrRange_free(aor);
return 0;
}
+LCRYPTO_ALIAS(X509v3_asid_add_id_or_range)
/*
* Extract min and max values from an ASIdOrRange.
(ASIdentifierChoice_is_canonical(asid->asnum) &&
ASIdentifierChoice_is_canonical(asid->rdi)));
}
+LCRYPTO_ALIAS(X509v3_asid_is_canonical)
/*
* Whack an ASIdentifierChoice into canonical form.
return ASIdentifierChoice_canonize(asid->rdi);
}
+LCRYPTO_ALIAS(X509v3_asid_canonize)
/*
* v2i method for an ASIdentifier extension.
return 0;
}
+LCRYPTO_ALIAS(X509v3_asid_inherits)
/*
* Figure out whether parent contains child.
return 1;
}
+LCRYPTO_ALIAS(X509v3_asid_subset)
/*
* Validation error handling via callback.
}
return asid_validate_path_internal(ctx, ctx->chain, NULL);
}
+LCRYPTO_ALIAS(X509v3_asid_validate_path)
/*
* RFC 3779 3.3 path validation of an extension.
return 0;
return asid_validate_path_internal(NULL, chain, ext);
}
+LCRYPTO_ALIAS(X509v3_asid_validate_resource_set)
#endif /* OPENSSL_NO_RFC3779 */
-/* $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.
*
{
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)
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,
}
return (-1);
}
+LCRYPTO_ALIAS(X509at_get_attr_by_OBJ)
X509_ATTRIBUTE *
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)
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)
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,
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,
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,
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,
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,
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,
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,
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)
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,
X509error(ERR_R_MALLOC_FAILURE);
return 0;
}
+LCRYPTO_ALIAS(X509_ATTRIBUTE_set1_data)
int
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)
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)
}
return ttmp->value.ptr;
}
+LCRYPTO_ALIAS(X509_ATTRIBUTE_get0_data)
ASN1_TYPE *
X509_ATTRIBUTE_get0_type(X509_ATTRIBUTE *attr, int idx)
return sk_ASN1_TYPE_value(attr->set, idx);
}
+LCRYPTO_ALIAS(X509_ATTRIBUTE_get0_type)
-/* $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.
*/
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) *
-/* $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.
*/
return NULL;
}
+LCRYPTO_ALIAS(i2v_ASN1_BIT_STRING)
ASN1_BIT_STRING *
v2i_ASN1_BIT_STRING(X509V3_EXT_METHOD *method, X509V3_CTX *ctx,
}
return bs;
}
+LCRYPTO_ALIAS(v2i_ASN1_BIT_STRING)
-/* $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.
*
return (i);
return (X509_NAME_cmp(ai->issuer, bi->issuer));
}
+LCRYPTO_ALIAS(X509_issuer_and_serial_cmp)
#ifndef OPENSSL_NO_MD5
unsigned long
free(f);
return (ret);
}
+LCRYPTO_ALIAS(X509_issuer_and_serial_hash)
#endif
int
{
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
{
return memcmp(a->hash, b->hash, X509_CRL_HASH_LEN);
}
+LCRYPTO_ALIAS(X509_CRL_match)
#endif
X509_NAME *
{
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
{
return (X509_NAME_hash_old(x->cert_info->issuer));
}
+LCRYPTO_ALIAS(X509_issuer_name_hash_old)
#endif
X509_NAME *
{
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
{
return (X509_NAME_hash_old(x->cert_info->subject));
}
+LCRYPTO_ALIAS(X509_subject_name_hash_old)
#endif
#ifndef OPENSSL_NO_SHA
return memcmp(a->hash, b->hash, X509_CERT_HASH_LEN);
}
+LCRYPTO_ALIAS(X509_cmp)
#endif
int
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)
0xffffffffL;
return (ret);
}
+LCRYPTO_ALIAS(X509_NAME_hash)
#ifndef OPENSSL_NO_MD5
return (ret);
}
+LCRYPTO_ALIAS(X509_NAME_hash_old)
#endif
/* Search a stack of X509 for a match */
}
return (NULL);
}
+LCRYPTO_ALIAS(X509_find_by_issuer_and_serial)
X509 *
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)
return (NULL);
return (X509_PUBKEY_get(x->cert_info->key));
}
+LCRYPTO_ALIAS(X509_get_pubkey)
EVP_PKEY *
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)
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)
return 1;
return 0;
}
+LCRYPTO_ALIAS(X509_check_private_key)
/*
* Not strictly speaking an "up_ref" as a STACK doesn't have a reference
return ret;
}
+LCRYPTO_ALIAS(X509_chain_up_ref)
-/* $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.
*/
}
return ret;
}
+LCRYPTO_ALIAS(X509V3_EXT_nconf)
/* CONF *conf: Config file */
/* char *value: Value */
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 */
}
return do_ext_i2d(method, ext_nid, crit, ext_struc);
}
+LCRYPTO_ALIAS(X509V3_EXT_i2d)
/* Check the extension string for critical flag */
static int
}
return 1;
}
+LCRYPTO_ALIAS(X509V3_EXT_add_nconf_sk)
/* Convenience functions to add extensions to a certificate, CRL and request */
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 */
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 */
sk_X509_EXTENSION_pop_free(extlist, X509_EXTENSION_free);
return i;
}
+LCRYPTO_ALIAS(X509V3_EXT_REQ_add_nconf)
/* Config database functions */
}
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)
}
return ctx->db_meth->get_section(ctx->db, section);
}
+LCRYPTO_ALIAS(X509V3_get_section)
void
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)
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)
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,
ctx->subject_req = req;
ctx->flags = flags;
}
+LCRYPTO_ALIAS(X509V3_set_ctx)
/* Old conf compatibility functions */
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 */
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)
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,
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 */
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 */
CONF_set_nconf(&ctmp, conf);
return X509V3_EXT_REQ_add_nconf(&ctmp, ctx, section, req);
}
+LCRYPTO_ALIAS(X509V3_EXT_REQ_add_conf)
-/* $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.
*/
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[] = {
{
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,
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[] = {
{
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[] = {
{
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)
else
BIO_printf(out, "%*sNo Qualifiers\n", indent + 2, "");
}
+LCRYPTO_ALIAS(X509_POLICY_NODE_print)
-/* $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.
*/
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[] = {
{
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,
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[] = {
{
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);
}
return 1;
}
+LCRYPTO_ALIAS(DIST_POINT_set_dpname)
-/* $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.
*
return (1);
}
+LCRYPTO_ALIAS(X509_STORE_set_default_paths)
int
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)
return (1);
}
+LCRYPTO_ALIAS(X509_STORE_load_mem)
-/* $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.
*
{
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)
-/* $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.
*/
}
return i2s_ASN1_ENUMERATED(method, e);
}
+LCRYPTO_ALIAS(i2s_ASN1_ENUMERATED_TABLE)
-/* $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.
*
}
#endif
}
+LCRYPTO_ALIAS(ERR_load_X509_strings)
void
}
#endif
}
+LCRYPTO_ALIAS(ERR_load_X509V3_strings)
-/* $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.
*
{
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,
{
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)
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)
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,
{
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,
{
return X509V3_add1_i2d(&x->extensions, nid, value, crit, flags);
}
+LCRYPTO_ALIAS(X509_REVOKED_add1_ext_i2d)
-/* $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.
*/
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,
-/* $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.
*/
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[] = {
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[] = {
{
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,
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)
}
return result;
}
+LCRYPTO_ALIAS(GENERAL_NAME_cmp)
/* Returns 0 if they are equal, != 0 otherwise. */
int
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)
}
a->type = type;
}
+LCRYPTO_ALIAS(GENERAL_NAME_set0_value)
void *
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,
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,
*pvalue = gen->d.otherName->value;
return 1;
}
+LCRYPTO_ALIAS(GENERAL_NAME_get0_otherName)
-/* $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.
*/
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,
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,
i2a_ASN1_OBJECT(bp, a->method);
return 2;
}
+LCRYPTO_ALIAS(i2a_ACCESS_DESCRIPTION)
-/* $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.
*/
}
return 1;
}
+LCRYPTO_ALIAS(X509V3_EXT_add)
static int
ext_cmp(const X509V3_EXT_METHOD * const *a, const X509V3_EXT_METHOD * const *b)
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)
return NULL;
return X509V3_EXT_get_nid(nid);
}
+LCRYPTO_ALIAS(X509V3_EXT_get)
int
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)
}
return 1;
}
+LCRYPTO_ALIAS(X509V3_EXT_add_alias)
void
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)
{
return 1;
}
+LCRYPTO_ALIAS(X509V3_add_standard_extensions)
/* Return an extension internal structure */
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
*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
X509V3error(errcode);
return 0;
}
+LCRYPTO_ALIAS(X509V3_add1_i2d)
-/* $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.
*
return lu;
}
+LCRYPTO_ALIAS(X509_LOOKUP_new)
void
X509_LOOKUP_free(X509_LOOKUP *ctx)
ctx->method->free(ctx);
free(ctx);
}
+LCRYPTO_ALIAS(X509_LOOKUP_free)
int
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)
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,
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,
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,
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,
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,
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)
return NULL;
}
+LCRYPTO_ALIAS(X509_STORE_new)
X509_OBJECT *
X509_OBJECT_new(void)
return obj;
}
+LCRYPTO_ALIAS(X509_OBJECT_new)
void
X509_OBJECT_free(X509_OBJECT *a)
free(a);
}
+LCRYPTO_ALIAS(X509_OBJECT_free)
void
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)
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,
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,
return 1;
}
+LCRYPTO_ALIAS(X509_STORE_CTX_get_by_subject)
/* Add obj to the store. Takes ownership of obj. */
static int
return X509_STORE_add_object(store, obj);
}
+LCRYPTO_ALIAS(X509_STORE_add_cert)
int
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)
}
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,
{
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,
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)
return xo->data.x509;
return NULL;
}
+LCRYPTO_ALIAS(X509_OBJECT_get0_X509)
X509_CRL *
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)
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)
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)
}
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
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)
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)
-/* $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.
*/
{
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,
}
return X509_V_OK;
}
+LCRYPTO_ALIAS(NAME_CONSTRAINTS_check)
static int
nc_match(GENERAL_NAME *gen, NAME_CONSTRAINTS *nc)
{
-/* $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.
*
BUF_MEM_free(b);
return (NULL);
}
+LCRYPTO_ALIAS(X509_NAME_oneline)
-/* $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)
*/
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[] = {
{
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)
-/* $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.
*/
{
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,
-/* $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.
*/
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,
-/* $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.
*/
{
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,
-/* $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.
*/
BIO_puts(out, "\n");
}
}
+LCRYPTO_ALIAS(X509V3_EXT_val_prn)
/* Main routine: print out a general extension */
method->ext_free(ext_str);
return ok;
}
+LCRYPTO_ALIAS(X509V3_EXT_print)
int
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,
BIO_free(bio_tmp);
return ret;
}
+LCRYPTO_ALIAS(X509V3_EXT_print_fp)
-/* $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.
*/
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)
*p = purpose;
return 1;
}
+LCRYPTO_ALIAS(X509_PURPOSE_set)
int
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)
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)
}
return -1;
}
+LCRYPTO_ALIAS(X509_PURPOSE_get_by_sname)
int
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,
X509V3error(ERR_R_MALLOC_FAILURE);
return 0;
}
+LCRYPTO_ALIAS(X509_PURPOSE_add)
static void
xptable_free(X509_PURPOSE *p)
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)
return 1;
return 0;
}
+LCRYPTO_ALIAS(X509_supported_extension)
static void
setup_dp(X509 *x, DIST_POINT *dp)
return check_ca(x);
}
+LCRYPTO_ALIAS(X509_check_ca)
/* Check SSL CA: common checks for SSL client and server */
static int
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)
}
return X509_V_OK;
}
+LCRYPTO_ALIAS(X509_check_akid)
uint32_t
X509_get_extension_flags(X509 *x)
return x->ex_flags;
}
+LCRYPTO_ALIAS(X509_get_extension_flags)
uint32_t
X509_get_key_usage(X509 *x)
return UINT32_MAX;
}
+LCRYPTO_ALIAS(X509_get_key_usage)
uint32_t
X509_get_extended_key_usage(X509 *x)
return UINT32_MAX;
}
+LCRYPTO_ALIAS(X509_get_extended_key_usage)
-/* $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.
*
X509_free(ret);
return NULL;
}
+LCRYPTO_ALIAS(X509_REQ_to_X509)
-/* $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.
*
X509_REQ_free(ret);
return (NULL);
}
+LCRYPTO_ALIAS(X509_to_X509_REQ)
EVP_PKEY *
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)
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)
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
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)
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
return rv;
}
+LCRYPTO_ALIAS(X509_REQ_add_extensions_nid)
/* This is the normal usage: use the "official" OID */
int
{
return X509_REQ_add_extensions_nid(req, exts, NID_ext_req);
}
+LCRYPTO_ALIAS(X509_REQ_add_extensions)
/* Request attribute functions */
{
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,
{
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)
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,
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,
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,
return 1;
return 0;
}
+LCRYPTO_ALIAS(X509_REQ_add1_attr_by_txt)
int
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)
-/* $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.
*
{
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)
}
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)
}
return (in != NULL);
}
+LCRYPTO_ALIAS(X509_set_serialNumber)
int
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)
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)
return (NULL);
return x->cert_info->validity->notBefore;
}
+LCRYPTO_ALIAS(X509_getm_notBefore)
int
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)
return (NULL);
return x->cert_info->validity->notAfter;
}
+LCRYPTO_ALIAS(X509_getm_notAfter)
int
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)
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)
-/* $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.
*/
{
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,
return oct;
}
+LCRYPTO_ALIAS(s2i_ASN1_OCTET_STRING)
static ASN1_OCTET_STRING *
s2i_skey_id(X509V3_EXT_METHOD *method, X509V3_CTX *ctx, char *str)
-/* $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.
*/
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[] = {
{
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)
}
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 */
}
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
*psx = NULL;
return 0;
}
+LCRYPTO_ALIAS(SXNET_add_id_INTEGER)
ASN1_OCTET_STRING *
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)
ASN1_INTEGER_free(izone);
return oct;
}
+LCRYPTO_ALIAS(SXNET_get_id_ulong)
ASN1_OCTET_STRING *
SXNET_get_id_INTEGER(SXNET *sx, ASN1_INTEGER *zone)
}
return NULL;
}
+LCRYPTO_ALIAS(SXNET_get_id_INTEGER)
-/* $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.
*/
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)
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)
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)
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)
return -1;
return idx + X509_TRUST_COUNT;
}
+LCRYPTO_ALIAS(X509_TRUST_get_by_id)
int
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),
X509error(ERR_R_MALLOC_FAILURE);
return 0;
}
+LCRYPTO_ALIAS(X509_TRUST_add)
static void
trtable_free(X509_TRUST *p)
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)
-/* $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.
*
return(buf);
}
}
+LCRYPTO_ALIAS(X509_verify_cert_error_string)
-/* $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.
*/
}
return 0;
}
+LCRYPTO_ALIAS(X509V3_add_value)
int
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) */
free(conf->section);
free(conf);
}
+LCRYPTO_ALIAS(X509V3_conf_free)
int
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,
return X509V3_add_value(name, "TRUE", extlist);
return 1;
}
+LCRYPTO_ALIAS(X509V3_add_value_bool_nf)
char *
bn_to_string(const BIGNUM *bn)
BN_free(bntmp);
return strtmp;
}
+LCRYPTO_ALIAS(i2s_ASN1_ENUMERATED)
char *
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)
aint->type |= V_ASN1_NEG;
return aint;
}
+LCRYPTO_ALIAS(s2i_ASN1_INTEGER)
int
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)
X509V3_conf_err(value);
return 0;
}
+LCRYPTO_ALIAS(X509V3_get_value_bool)
int
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
return NULL;
}
+LCRYPTO_ALIAS(X509V3_parse_list)
/* Delete leading and trailing spaces from a string */
static char *
q[-1] = 0;
return tmp;
}
+LCRYPTO_ALIAS(hex_to_string)
/* Give a string of hex digits convert to
* a buffer
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.*
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)
AUTHORITY_INFO_ACCESS_free(info);
return ret;
}
+LCRYPTO_ALIAS(X509_get1_ocsp)
STACK_OF(OPENSSL_STRING) *
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) *
{
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);
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)
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,
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)
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.
}
return ret;
}
+LCRYPTO_ALIAS(a2i_IPADDRESS)
ASN1_OCTET_STRING *
a2i_IPADDRESS_NC(const char *ipasc)
ASN1_OCTET_STRING_free(ret);
return NULL;
}
+LCRYPTO_ALIAS(a2i_IPADDRESS_NC)
int
return 4;
}
}
+LCRYPTO_ALIAS(a2i_ipadd)
static int
ipv4_from_asc(unsigned char *v4, const char *in)
}
return 1;
}
+LCRYPTO_ALIAS(X509V3_NAME_from_section)
-/* $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.
*
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)
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,
}
return (-1);
}
+LCRYPTO_ALIAS(X509v3_get_ext_by_OBJ)
int
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)
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)
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)
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,
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,
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)
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)
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)
return (0);
return (1);
}
+LCRYPTO_ALIAS(X509_EXTENSION_set_data)
ASN1_OBJECT *
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)
return (NULL);
return (ex->value);
}
+LCRYPTO_ALIAS(X509_EXTENSION_get_data)
int
X509_EXTENSION_get_critical(const X509_EXTENSION *ex)
return 1;
return 0;
}
+LCRYPTO_ALIAS(X509_EXTENSION_get_critical)
-/* $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.
*
/* 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)
*/
{
return X509_cmp_time(ctm, NULL);
}
+LCRYPTO_ALIAS(X509_cmp_current_time)
/*
* Compare a possibly unvalidated ASN1_TIME string against a time_t
{
return X509_cmp_time_internal(ctm, cmp_time, 0);
}
+LCRYPTO_ALIAS(X509_cmp_time)
ASN1_TIME *
{
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)
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)
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,
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)
}
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
ctx->param->trust = trust;
return 1;
}
+LCRYPTO_ALIAS(X509_STORE_CTX_purpose_inherit)
X509_STORE_CTX *
X509_STORE_CTX_new(void)
}
return ctx;
}
+LCRYPTO_ALIAS(X509_STORE_CTX_new)
void
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,
}
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.
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)
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,
{
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)
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)
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)
X509_VERIFY_PARAM_free(ctx->param);
ctx->param = param;
}
+LCRYPTO_ALIAS(X509_STORE_CTX_set0_param)
/*
* Check if |bits| are adequate for |security level|.
-/* $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.
*/
x509_verify_param_zero(param);
return param;
}
+LCRYPTO_ALIAS(X509_VERIFY_PARAM_new)
void
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
return 1;
}
+LCRYPTO_ALIAS(X509_VERIFY_PARAM_inherit)
int
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,
return 1;
return 0;
}
+LCRYPTO_ALIAS(X509_VERIFY_PARAM_set1_name)
int
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)
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)
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)
return 0;
return 1;
}
+LCRYPTO_ALIAS(X509_VERIFY_PARAM_add0_policy)
int
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,
param->id->poisoned = 1;
return 0;
}
+LCRYPTO_ALIAS(X509_VERIFY_PARAM_set1_host)
int
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,
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,
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)
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 };
return 0;
return 1;
}
+LCRYPTO_ALIAS(X509_VERIFY_PARAM_add0_table)
int
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)
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)
}
return NULL;
}
+LCRYPTO_ALIAS(X509_VERIFY_PARAM_lookup)
void
X509_VERIFY_PARAM_table_cleanup(void)
X509_VERIFY_PARAM_free);
param_table = NULL;
}
+LCRYPTO_ALIAS(X509_VERIFY_PARAM_table_cleanup)
-/* $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.
*/
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)
}
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)
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)
}
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)
}
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)
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)
}
return (in != NULL);
}
+LCRYPTO_ALIAS(X509_REVOKED_set_revocationDate)
int
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)
crl->crl->enc.modified = 1;
return i2d_X509_CRL_INFO(crl->crl, pp);
}
+LCRYPTO_ALIAS(i2d_re_X509_CRL_tbs)
-/* $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.
*
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,
}
return (i);
}
+LCRYPTO_ALIAS(X509_NAME_get_text_by_OBJ)
int
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)
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
}
return (-1);
}
+LCRYPTO_ALIAS(X509_NAME_get_index_by_OBJ)
X509_NAME_ENTRY *
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)
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,
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,
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,
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. */
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,
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,
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,
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)
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,
}
return (1);
}
+LCRYPTO_ALIAS(X509_NAME_ENTRY_set_data)
ASN1_OBJECT *
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)
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)
-/* $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.
*
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)
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)
x->req_info->enc.modified = 1;
return (X509_PUBKEY_set(&x->req_info->pubkey, pkey));
}
+LCRYPTO_ALIAS(X509_REQ_set_pubkey)
-/* $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.
*/
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)
return (NULL);
return (X509_PUBKEY_get(x->spkac->pubkey));
}
+LCRYPTO_ALIAS(NETSCAPE_SPKI_get_pubkey)
/* Load a Netscape SPKI from a base64 encoded string */
free(spki_der);
return spki;
}
+LCRYPTO_ALIAS(NETSCAPE_SPKI_b64_decode)
/* Generate a base64 encoded string from an SPKI */
free(der_spki);
return b64_str;
}
+LCRYPTO_ALIAS(NETSCAPE_SPKI_b64_encode)
-/* $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.
*
ret |= EVP_PKT_EXP;
return (ret);
}
+LCRYPTO_ALIAS(X509_certificate_type)
-/* $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.
*
{
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 *
{
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
{
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
{
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 *
{
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)
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)
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)
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)
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)
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)
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)
PKCS8_PRIV_KEY_INFO_free(p8inf);
return ret;
}
+LCRYPTO_ALIAS(i2d_PKCS8PrivateKeyInfo_bio)
int
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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,
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,
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,
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,
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,
return (ASN1_item_digest(&X509_NAME_it, type, (char *)data,
md, len));
}
+LCRYPTO_ALIAS(X509_NAME_digest)
int
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)
projects / openbsd / commitdiff