ffi.h File Reference

Public Header. More...

#include <stddef.h>
#include <stdint.h>

Go to the source code of this file.

Macros
#define	BOTAN_CHECK_KEY_EXPENSIVE_TESTS   1
#define	BOTAN_CIPHER_INIT_FLAG_DECRYPT   1
#define	BOTAN_CIPHER_INIT_FLAG_ENCRYPT   0
#define	BOTAN_CIPHER_INIT_FLAG_MASK_DIRECTION   1
#define	BOTAN_CIPHER_UPDATE_FLAG_FINAL   (1U << 0)
#define	BOTAN_FFI_API_VERSION   20260506
#define	BOTAN_FFI_DEPRECATED(msg)
#define	BOTAN_FFI_EXPORT(maj, min)
#define	BOTAN_FFI_HEX_LOWER_CASE   1
#define	BOTAN_FPE_FLAG_FE1_COMPAT_MODE   1
#define	BOTAN_PRIVKEY_EXPORT_FLAG_DER   0
#define	BOTAN_PRIVKEY_EXPORT_FLAG_PEM   1
#define	BOTAN_PRIVKEY_EXPORT_FLAG_RAW   2
#define	BOTAN_PUBKEY_DER_FORMAT_SIGNATURE   1

Typedefs
typedef struct botan_asn1_oid_struct *	botan_asn1_oid_t
typedef struct botan_block_cipher_struct *	botan_block_cipher_t
typedef struct botan_cipher_struct *	botan_cipher_t
typedef struct botan_ec_group_struct *	botan_ec_group_t
typedef struct botan_ec_point_struct *	botan_ec_point_t
typedef struct botan_ec_scalar_struct *	botan_ec_scalar_t
typedef struct botan_fpe_struct *	botan_fpe_t
typedef struct botan_hash_struct *	botan_hash_t
typedef struct botan_hotp_struct *	botan_hotp_t
typedef struct botan_mac_struct *	botan_mac_t
typedef struct botan_mp_struct *	botan_mp_t
typedef struct botan_pk_op_decrypt_struct *	botan_pk_op_decrypt_t
typedef struct botan_pk_op_encrypt_struct *	botan_pk_op_encrypt_t
typedef struct botan_pk_op_ka_struct *	botan_pk_op_ka_t
typedef struct botan_pk_op_kem_decrypt_struct *	botan_pk_op_kem_decrypt_t
typedef struct botan_pk_op_kem_encrypt_struct *	botan_pk_op_kem_encrypt_t
typedef struct botan_pk_op_sign_struct *	botan_pk_op_sign_t
typedef struct botan_pk_op_verify_struct *	botan_pk_op_verify_t
typedef struct botan_privkey_struct *	botan_privkey_t
typedef struct botan_pubkey_struct *	botan_pubkey_t
typedef struct botan_rng_struct *	botan_rng_t
typedef struct botan_srp6_server_session_struct *	botan_srp6_server_session_t
typedef struct botan_totp_struct *	botan_totp_t
typedef struct botan_tpm2_crypto_backend_state_struct *	botan_tpm2_crypto_backend_state_t
typedef struct botan_tpm2_ctx_struct *	botan_tpm2_ctx_t
typedef struct botan_tpm2_session_struct *	botan_tpm2_session_t
typedef int(*	botan_view_bin_fn) (botan_view_ctx view_ctx, const uint8_t *data, size_t len)
typedef void *	botan_view_ctx
typedef int(*	botan_view_str_fn) (botan_view_ctx view_ctx, const char *str, size_t len)
typedef struct botan_x509_cert_struct *	botan_x509_cert_t
typedef struct botan_x509_crl_entry_struct *	botan_x509_crl_entry_t
typedef struct botan_x509_crl_struct *	botan_x509_crl_t
typedef struct botan_x509_general_name_struct *	botan_x509_general_name_t
typedef struct botan_xof_struct *	botan_xof_t

Enumerations
enum	BOTAN_FFI_ERROR {   BOTAN_FFI_SUCCESS = 0 , BOTAN_FFI_INVALID_VERIFIER = 1 , BOTAN_FFI_ERROR_INVALID_INPUT = -1 , BOTAN_FFI_ERROR_BAD_MAC = -2 ,   BOTAN_FFI_ERROR_NO_VALUE = -3 , BOTAN_FFI_ERROR_INSUFFICIENT_BUFFER_SPACE = -10 , BOTAN_FFI_ERROR_STRING_CONVERSION_ERROR = -11 , BOTAN_FFI_ERROR_EXCEPTION_THROWN = -20 ,   BOTAN_FFI_ERROR_OUT_OF_MEMORY = -21 , BOTAN_FFI_ERROR_SYSTEM_ERROR = -22 , BOTAN_FFI_ERROR_INTERNAL_ERROR = -23 , BOTAN_FFI_ERROR_BAD_FLAG = -30 ,   BOTAN_FFI_ERROR_NULL_POINTER = -31 , BOTAN_FFI_ERROR_BAD_PARAMETER = -32 , BOTAN_FFI_ERROR_KEY_NOT_SET = -33 , BOTAN_FFI_ERROR_INVALID_KEY_LENGTH = -34 ,   BOTAN_FFI_ERROR_INVALID_OBJECT_STATE = -35 , BOTAN_FFI_ERROR_OUT_OF_RANGE = -36 , BOTAN_FFI_ERROR_NOT_IMPLEMENTED = -40 , BOTAN_FFI_ERROR_INVALID_OBJECT = -50 ,   BOTAN_FFI_ERROR_TLS_ERROR = -75 , BOTAN_FFI_ERROR_HTTP_ERROR = -76 , BOTAN_FFI_ERROR_ROUGHTIME_ERROR = -77 , BOTAN_FFI_ERROR_TPM_ERROR = -78 ,   BOTAN_FFI_ERROR_UNKNOWN_ERROR = -100 }
enum	botan_x509_cert_key_constraints {   NO_CONSTRAINTS = 0 , DIGITAL_SIGNATURE = 32768 , NON_REPUDIATION = 16384 , KEY_ENCIPHERMENT = 8192 ,   DATA_ENCIPHERMENT = 4096 , KEY_AGREEMENT = 2048 , KEY_CERT_SIGN = 1024 , CRL_SIGN = 512 ,   ENCIPHER_ONLY = 256 , DECIPHER_ONLY = 128 }
enum	botan_x509_crl_reason_code {   BOTAN_CRL_ENTRY_UNSPECIFIED = 0 , BOTAN_CRL_ENTRY_KEY_COMPROMISE = 1 , BOTAN_CRL_ENTRY_CA_COMPROMISE = 2 , BOTAN_CRL_ENTRY_AFFILIATION_CHANGED = 3 ,   BOTAN_CRL_ENTRY_SUPERSEDED = 4 , BOTAN_CRL_ENTRY_CESSATION_OF_OPERATION = 5 , BOTAN_CRL_ENTRY_CERTIFICATE_HOLD = 6 , BOTAN_CRL_ENTRY_REMOVE_FROM_CRL = 8 ,   BOTAN_CRL_ENTRY_PRIVILEGE_WITHDRAWN = 9 , BOTAN_CRL_ENTRY_AA_COMPROMISE = 10 }
enum	botan_x509_general_name_types {   BOTAN_X509_OTHER_NAME = 0 , BOTAN_X509_EMAIL_ADDRESS = 1 , BOTAN_X509_DNS_NAME = 2 , BOTAN_X509_DIRECTORY_NAME = 4 ,   BOTAN_X509_URI = 6 , BOTAN_X509_IP_ADDRESS = 7 }
enum	botan_x509_value_type {   BOTAN_X509_SERIAL_NUMBER = 0 , BOTAN_X509_SUBJECT_DN_BITS = 1 , BOTAN_X509_ISSUER_DN_BITS = 2 , BOTAN_X509_SUBJECT_KEY_IDENTIFIER = 3 ,   BOTAN_X509_AUTHORITY_KEY_IDENTIFIER = 4 , BOTAN_X509_PUBLIC_KEY_PKCS8_BITS = 200 , BOTAN_X509_TBS_DATA_BITS = 201 , BOTAN_X509_SIGNATURE_SCHEME_BITS = 202 ,   BOTAN_X509_SIGNATURE_BITS = 203 , BOTAN_X509_DER_ENCODING = 300 , BOTAN_X509_PEM_ENCODING = 301 , BOTAN_X509_CRL_DISTRIBUTION_URLS = 400 ,   BOTAN_X509_OCSP_RESPONDER_URLS = 401 , BOTAN_X509_CA_ISSUERS_URLS = 402 }

Functions
int	botan_base64_decode (const char *base64_str, size_t in_len, uint8_t *out, size_t *out_len)
int	botan_base64_encode (const uint8_t *x, size_t len, char *out, size_t *out_len)
int	botan_bcrypt_generate (uint8_t *out, size_t *out_len, const char *password, botan_rng_t rng, size_t work_factor, uint32_t flags)
int	botan_bcrypt_is_valid (const char *pass, const char *hash)
int	botan_block_cipher_block_size (botan_block_cipher_t bc)
int	botan_block_cipher_clear (botan_block_cipher_t bc)
int	botan_block_cipher_decrypt_blocks (botan_block_cipher_t bc, const uint8_t in[], uint8_t out[], size_t blocks)
int	botan_block_cipher_destroy (botan_block_cipher_t bc)
int	botan_block_cipher_encrypt_blocks (botan_block_cipher_t bc, const uint8_t in[], uint8_t out[], size_t blocks)
int	botan_block_cipher_get_keyspec (botan_block_cipher_t cipher, size_t *out_minimum_keylength, size_t *out_maximum_keylength, size_t *out_keylength_modulo)
int	botan_block_cipher_init (botan_block_cipher_t *bc, const char *cipher_name)
int	botan_block_cipher_name (botan_block_cipher_t cipher, char *name, size_t *name_len)
int	botan_block_cipher_set_key (botan_block_cipher_t bc, const uint8_t key[], size_t len)
int	botan_cipher_clear (botan_cipher_t hash)
int	botan_cipher_destroy (botan_cipher_t cipher)
int	botan_cipher_get_default_nonce_length (botan_cipher_t cipher, size_t *nl)
int	botan_cipher_get_ideal_update_granularity (botan_cipher_t cipher, size_t *ug)
int	botan_cipher_get_keyspec (botan_cipher_t cipher, size_t *min_keylen, size_t *max_keylen, size_t *mod_keylen)
int	botan_cipher_get_tag_length (botan_cipher_t cipher, size_t *tag_size)
int	botan_cipher_get_update_granularity (botan_cipher_t cipher, size_t *ug)
int	botan_cipher_init (botan_cipher_t *cipher, const char *name, uint32_t flags)
int	botan_cipher_is_authenticated (botan_cipher_t cipher)
int	botan_cipher_name (botan_cipher_t cipher, char *name, size_t *name_len)
int	botan_cipher_output_length (botan_cipher_t cipher, size_t in_len, size_t *out_len)
int	botan_cipher_query_keylen (botan_cipher_t cipher, size_t *out_minimum_keylength, size_t *out_maximum_keylength)
int	botan_cipher_requires_entire_message (botan_cipher_t cipher)
int	botan_cipher_reset (botan_cipher_t cipher)
int	botan_cipher_set_associated_data (botan_cipher_t cipher, const uint8_t *ad, size_t ad_len)
int	botan_cipher_set_key (botan_cipher_t cipher, const uint8_t *key, size_t key_len)
int	botan_cipher_start (botan_cipher_t cipher, const uint8_t *nonce, size_t nonce_len)
int	botan_cipher_update (botan_cipher_t cipher, uint32_t flags, uint8_t output[], size_t output_size, size_t *output_written, const uint8_t input_bytes[], size_t input_size, size_t *input_consumed)
	Encrypt/Decrypt some data and/or finalize the encryption/decryption.
int	botan_cipher_valid_nonce_length (botan_cipher_t cipher, size_t nl)
int	botan_constant_time_compare (const uint8_t *x, const uint8_t *y, size_t len)
int	botan_ec_group_destroy (botan_ec_group_t ec_group)
int	botan_ec_group_equal (botan_ec_group_t curve1, botan_ec_group_t curve2)
int	botan_ec_group_from_ber (botan_ec_group_t *ec_group, const uint8_t *ber, size_t ber_len)
int	botan_ec_group_from_name (botan_ec_group_t *ec_group, const char *name)
int	botan_ec_group_from_oid (botan_ec_group_t *ec_group, botan_asn1_oid_t oid)
int	botan_ec_group_from_params (botan_ec_group_t *ec_group, botan_asn1_oid_t oid, botan_mp_t p, botan_mp_t a, botan_mp_t b, botan_mp_t base_x, botan_mp_t base_y, botan_mp_t order)
int	botan_ec_group_from_pem (botan_ec_group_t *ec_group, const char *pem)
int	botan_ec_group_get_a (botan_mp_t *a, botan_ec_group_t ec_group)
int	botan_ec_group_get_b (botan_mp_t *b, botan_ec_group_t ec_group)
int	botan_ec_group_get_curve_oid (botan_asn1_oid_t *oid, botan_ec_group_t ec_group)
int	botan_ec_group_get_g_x (botan_mp_t *g_x, botan_ec_group_t ec_group)
int	botan_ec_group_get_g_y (botan_mp_t *g_y, botan_ec_group_t ec_group)
int	botan_ec_group_get_order (botan_mp_t *order, botan_ec_group_t ec_group)
int	botan_ec_group_get_p (botan_mp_t *p, botan_ec_group_t ec_group)
int	botan_ec_group_supports_application_specific_group (int *out)
int	botan_ec_group_supports_named_group (const char *name, int *out)
int	botan_ec_group_unregister (botan_asn1_oid_t oid)
int	botan_ec_group_view_der (botan_ec_group_t ec_group, botan_view_ctx ctx, botan_view_bin_fn view)
int	botan_ec_group_view_pem (botan_ec_group_t ec_group, botan_view_ctx ctx, botan_view_str_fn view)
int	botan_ec_point_add (botan_ec_point_t *result, botan_ec_point_t x, botan_ec_point_t y)
int	botan_ec_point_destroy (botan_ec_point_t ec_point)
int	botan_ec_point_equal (botan_ec_point_t x, botan_ec_point_t y)
int	botan_ec_point_from_bytes (botan_ec_point_t *ec_point, botan_ec_group_t ec_group, const uint8_t *bytes, size_t bytes_len)
int	botan_ec_point_from_xy (botan_ec_point_t *ec_point, botan_ec_group_t ec_group, botan_mp_t x, botan_mp_t y)
int	botan_ec_point_generator (botan_ec_point_t *ec_point, botan_ec_group_t ec_group)
int	botan_ec_point_identity (botan_ec_point_t *ec_point, botan_ec_group_t ec_group)
int	botan_ec_point_is_identity (botan_ec_point_t ec_point)
int	botan_ec_point_mul (botan_ec_point_t *result, botan_ec_point_t ec_point, botan_ec_scalar_t ec_scalar, botan_rng_t rng)
int	botan_ec_point_negate (botan_ec_point_t *result, botan_ec_point_t ec_point)
int	botan_ec_point_view_compressed (botan_ec_point_t ec_point, botan_view_ctx ctx, botan_view_bin_fn view)
int	botan_ec_point_view_uncompressed (botan_ec_point_t ec_point, botan_view_ctx ctx, botan_view_bin_fn view)
int	botan_ec_point_view_x_bytes (botan_ec_point_t ec_point, botan_view_ctx ctx, botan_view_bin_fn view)
int	botan_ec_point_view_xy_bytes (botan_ec_point_t ec_point, botan_view_ctx ctx, botan_view_bin_fn view)
int	botan_ec_point_view_y_bytes (botan_ec_point_t ec_point, botan_view_ctx ctx, botan_view_bin_fn view)
int	botan_ec_privkey_create (botan_privkey_t *key, const char *algo_name, botan_ec_group_t ec_group, botan_rng_t rng)
int	botan_ec_privkey_get_group (botan_privkey_t key, botan_ec_group_t *ec_group)
int	botan_ec_privkey_get_private_key (botan_privkey_t key, botan_ec_scalar_t *value)
int	botan_ec_pubkey_get_group (botan_pubkey_t key, botan_ec_group_t *ec_group)
int	botan_ec_scalar_destroy (botan_ec_scalar_t ec_scalar)
int	botan_ec_scalar_from_mp (botan_ec_scalar_t *ec_scalar, botan_ec_group_t ec_group, botan_mp_t mp)
int	botan_ec_scalar_random (botan_ec_scalar_t *ec_scalar, botan_ec_group_t ec_group, botan_rng_t rng)
int	botan_ec_scalar_to_mp (botan_ec_scalar_t ec_scalar, botan_mp_t *mp)
const char *	botan_error_description (int err)
const char *	botan_error_last_exception_message (void)
uint32_t	botan_ffi_api_version (void)
int	botan_ffi_supports_api (uint32_t api_version)
int	botan_fpe_decrypt (botan_fpe_t fpe, botan_mp_t x, const uint8_t tweak[], size_t tweak_len)
int	botan_fpe_destroy (botan_fpe_t fpe)
int	botan_fpe_encrypt (botan_fpe_t fpe, botan_mp_t x, const uint8_t tweak[], size_t tweak_len)
int	botan_fpe_fe1_init (botan_fpe_t *fpe, botan_mp_t n, const uint8_t key[], size_t key_len, size_t rounds, uint32_t flags)
int	botan_hash_block_size (botan_hash_t hash, size_t *block_size)
int	botan_hash_clear (botan_hash_t hash)
int	botan_hash_copy_state (botan_hash_t *dest, botan_hash_t source)
int	botan_hash_destroy (botan_hash_t hash)
int	botan_hash_final (botan_hash_t hash, uint8_t out[])
int	botan_hash_init (botan_hash_t *hash, const char *hash_name, uint32_t flags)
int	botan_hash_name (botan_hash_t hash, char *name, size_t *name_len)
int	botan_hash_output_length (botan_hash_t hash, size_t *output_length)
int	botan_hash_update (botan_hash_t hash, const uint8_t *in, size_t in_len)
int	botan_hex_decode (const char *hex_str, size_t in_len, uint8_t *out, size_t *out_len)
int	botan_hex_encode (const uint8_t *x, size_t len, char *out, uint32_t flags)
int	botan_hotp_check (botan_hotp_t hotp, uint64_t *next_hotp_counter, uint32_t hotp_code, uint64_t hotp_counter, size_t resync_range)
int	botan_hotp_destroy (botan_hotp_t hotp)
int	botan_hotp_generate (botan_hotp_t hotp, uint32_t *hotp_code, uint64_t hotp_counter)
int	botan_hotp_init (botan_hotp_t *hotp, const uint8_t key[], size_t key_len, const char *hash_algo, size_t digits)
int	botan_kdf (const char *kdf_algo, uint8_t out[], size_t out_len, const uint8_t secret[], size_t secret_len, const uint8_t salt[], size_t salt_len, const uint8_t label[], size_t label_len)
int	botan_key_unwrap3394 (const uint8_t wrapped_key[], size_t wrapped_key_len, const uint8_t kek[], size_t kek_len, uint8_t key[], size_t *key_len)
int	botan_key_wrap3394 (const uint8_t key[], size_t key_len, const uint8_t kek[], size_t kek_len, uint8_t wrapped_key[], size_t *wrapped_key_len)
int	botan_mac_clear (botan_mac_t mac)
int	botan_mac_destroy (botan_mac_t mac)
int	botan_mac_final (botan_mac_t mac, uint8_t out[])
int	botan_mac_get_keyspec (botan_mac_t mac, size_t *out_minimum_keylength, size_t *out_maximum_keylength, size_t *out_keylength_modulo)
int	botan_mac_init (botan_mac_t *mac, const char *mac_name, uint32_t flags)
int	botan_mac_name (botan_mac_t mac, char *name, size_t *name_len)
int	botan_mac_output_length (botan_mac_t mac, size_t *output_length)
int	botan_mac_set_key (botan_mac_t mac, const uint8_t *key, size_t key_len)
int	botan_mac_set_nonce (botan_mac_t mac, const uint8_t *nonce, size_t nonce_len)
int	botan_mac_update (botan_mac_t mac, const uint8_t *buf, size_t len)
int	botan_mceies_decrypt (botan_privkey_t mce_key, const char *aead, const uint8_t ct[], size_t ct_len, const uint8_t ad[], size_t ad_len, uint8_t pt[], size_t *pt_len)
int	botan_mceies_encrypt (botan_pubkey_t mce_key, botan_rng_t rng, const char *aead, const uint8_t pt[], size_t pt_len, const uint8_t ad[], size_t ad_len, uint8_t ct[], size_t *ct_len)
int	botan_mp_add (botan_mp_t result, botan_mp_t x, botan_mp_t y)
int	botan_mp_add_u32 (botan_mp_t result, botan_mp_t x, uint32_t y)
int	botan_mp_clear (botan_mp_t mp)
int	botan_mp_clear_bit (botan_mp_t n, size_t bit)
int	botan_mp_cmp (int *result, botan_mp_t x, botan_mp_t y)
int	botan_mp_destroy (botan_mp_t mp)
int	botan_mp_div (botan_mp_t quotient, botan_mp_t remainder, botan_mp_t x, botan_mp_t y)
int	botan_mp_equal (botan_mp_t x, botan_mp_t y)
int	botan_mp_flip_sign (botan_mp_t mp)
int	botan_mp_from_bin (botan_mp_t mp, const uint8_t vec[], size_t vec_len)
int	botan_mp_gcd (botan_mp_t out, botan_mp_t x, botan_mp_t y)
int	botan_mp_get_bit (botan_mp_t n, size_t bit)
int	botan_mp_init (botan_mp_t *mp)
int	botan_mp_is_even (botan_mp_t mp)
int	botan_mp_is_negative (botan_mp_t mp)
int	botan_mp_is_odd (botan_mp_t mp)
int	botan_mp_is_positive (botan_mp_t mp)
int	botan_mp_is_prime (botan_mp_t n, botan_rng_t rng, size_t test_prob)
int	botan_mp_is_zero (botan_mp_t mp)
int	botan_mp_lshift (botan_mp_t out, botan_mp_t in, size_t shift)
int	botan_mp_mod_inverse (botan_mp_t out, botan_mp_t in, botan_mp_t modulus)
int	botan_mp_mod_mul (botan_mp_t result, botan_mp_t x, botan_mp_t y, botan_mp_t mod)
int	botan_mp_mul (botan_mp_t result, botan_mp_t x, botan_mp_t y)
int	botan_mp_num_bits (botan_mp_t n, size_t *bits)
int	botan_mp_num_bytes (botan_mp_t n, size_t *bytes)
int	botan_mp_powmod (botan_mp_t out, botan_mp_t base, botan_mp_t exponent, botan_mp_t modulus)
int	botan_mp_rand_bits (botan_mp_t rand_out, botan_rng_t rng, size_t bits)
int	botan_mp_rand_range (botan_mp_t rand_out, botan_rng_t rng, botan_mp_t lower_bound, botan_mp_t upper_bound)
int	botan_mp_rshift (botan_mp_t out, botan_mp_t in, size_t shift)
int	botan_mp_set_bit (botan_mp_t n, size_t bit)
int	botan_mp_set_from_int (botan_mp_t mp, int initial_value)
int	botan_mp_set_from_mp (botan_mp_t dest, botan_mp_t source)
int	botan_mp_set_from_radix_str (botan_mp_t dest, const char *str, size_t radix)
int	botan_mp_set_from_str (botan_mp_t dest, const char *str)
int	botan_mp_sub (botan_mp_t result, botan_mp_t x, botan_mp_t y)
int	botan_mp_sub_u32 (botan_mp_t result, botan_mp_t x, uint32_t y)
int	botan_mp_swap (botan_mp_t x, botan_mp_t y)
int	botan_mp_to_bin (botan_mp_t mp, uint8_t vec[])
int	botan_mp_to_hex (botan_mp_t mp, char *out)
int	botan_mp_to_str (botan_mp_t mp, uint8_t radix, char *out, size_t *out_len)
int	botan_mp_to_uint32 (botan_mp_t mp, uint32_t *val)
int	botan_mp_view_bin (botan_mp_t mp, botan_view_ctx ctx, botan_view_bin_fn view)
int	botan_mp_view_hex (botan_mp_t mp, botan_view_ctx ctx, botan_view_str_fn view)
int	botan_mp_view_str (botan_mp_t mp, uint8_t radix, botan_view_ctx ctx, botan_view_str_fn view)
int	botan_nist_kw_dec (const char *cipher_algo, int padded, const uint8_t wrapped_key[], size_t wrapped_key_len, const uint8_t kek[], size_t kek_len, uint8_t key[], size_t *key_len)
int	botan_nist_kw_enc (const char *cipher_algo, int padded, const uint8_t key[], size_t key_len, const uint8_t kek[], size_t kek_len, uint8_t wrapped_key[], size_t *wrapped_key_len)
int	botan_oid_cmp (int *result, botan_asn1_oid_t a, botan_asn1_oid_t b)
int	botan_oid_destroy (botan_asn1_oid_t oid)
int	botan_oid_equal (botan_asn1_oid_t a, botan_asn1_oid_t b)
int	botan_oid_from_string (botan_asn1_oid_t *oid, const char *oid_str)
int	botan_oid_register (botan_asn1_oid_t oid, const char *name)
int	botan_oid_view_name (botan_asn1_oid_t oid, botan_view_ctx ctx, botan_view_str_fn view)
int	botan_oid_view_string (botan_asn1_oid_t oid, botan_view_ctx ctx, botan_view_str_fn view)
int	botan_pbkdf (const char *pbkdf_algo, uint8_t out[], size_t out_len, const char *passphrase, const uint8_t salt[], size_t salt_len, size_t iterations)
int	botan_pbkdf_timed (const char *pbkdf_algo, uint8_t out[], size_t out_len, const char *passphrase, const uint8_t salt[], size_t salt_len, size_t milliseconds_to_run, size_t *out_iterations_used)
int	botan_pk_op_decrypt (botan_pk_op_decrypt_t op, uint8_t out[], size_t *out_len, const uint8_t ciphertext[], size_t ciphertext_len)
int	botan_pk_op_decrypt_create (botan_pk_op_decrypt_t *op, botan_privkey_t key, const char *padding, uint32_t flags)
int	botan_pk_op_decrypt_destroy (botan_pk_op_decrypt_t op)
int	botan_pk_op_decrypt_output_length (botan_pk_op_decrypt_t op, size_t ctext_len, size_t *ptext_len)
int	botan_pk_op_encrypt (botan_pk_op_encrypt_t op, botan_rng_t rng, uint8_t out[], size_t *out_len, const uint8_t plaintext[], size_t plaintext_len)
int	botan_pk_op_encrypt_create (botan_pk_op_encrypt_t *op, botan_pubkey_t key, const char *padding, uint32_t flags)
int	botan_pk_op_encrypt_destroy (botan_pk_op_encrypt_t op)
int	botan_pk_op_encrypt_output_length (botan_pk_op_encrypt_t op, size_t ptext_len, size_t *ctext_len)
int	botan_pk_op_kem_decrypt_create (botan_pk_op_kem_decrypt_t *op, botan_privkey_t key, const char *kdf)
int	botan_pk_op_kem_decrypt_destroy (botan_pk_op_kem_decrypt_t op)
int	botan_pk_op_kem_decrypt_shared_key (botan_pk_op_kem_decrypt_t op, const uint8_t salt[], size_t salt_len, const uint8_t encapsulated_key[], size_t encapsulated_key_len, size_t desired_shared_key_len, uint8_t shared_key[], size_t *shared_key_len)
int	botan_pk_op_kem_decrypt_shared_key_length (botan_pk_op_kem_decrypt_t op, size_t desired_shared_key_length, size_t *output_shared_key_length)
int	botan_pk_op_kem_encrypt_create (botan_pk_op_kem_encrypt_t *op, botan_pubkey_t key, const char *kdf)
int	botan_pk_op_kem_encrypt_create_shared_key (botan_pk_op_kem_encrypt_t op, botan_rng_t rng, const uint8_t salt[], size_t salt_len, size_t desired_shared_key_len, uint8_t shared_key[], size_t *shared_key_len, uint8_t encapsulated_key[], size_t *encapsulated_key_len)
int	botan_pk_op_kem_encrypt_destroy (botan_pk_op_kem_encrypt_t op)
int	botan_pk_op_kem_encrypt_encapsulated_key_length (botan_pk_op_kem_encrypt_t op, size_t *output_encapsulated_key_length)
int	botan_pk_op_kem_encrypt_shared_key_length (botan_pk_op_kem_encrypt_t op, size_t desired_shared_key_length, size_t *output_shared_key_length)
int	botan_pk_op_key_agreement (botan_pk_op_ka_t op, uint8_t out[], size_t *out_len, const uint8_t other_key[], size_t other_key_len, const uint8_t salt[], size_t salt_len)
int	botan_pk_op_key_agreement_create (botan_pk_op_ka_t *op, botan_privkey_t key, const char *kdf, uint32_t flags)
int	botan_pk_op_key_agreement_destroy (botan_pk_op_ka_t op)
int	botan_pk_op_key_agreement_export_public (botan_privkey_t key, uint8_t out[], size_t *out_len)
int	botan_pk_op_key_agreement_size (botan_pk_op_ka_t op, size_t *out_len)
int	botan_pk_op_key_agreement_view_public (botan_privkey_t key, botan_view_ctx ctx, botan_view_bin_fn view)
int	botan_pk_op_sign_create (botan_pk_op_sign_t *op, botan_privkey_t key, const char *hash_and_padding, uint32_t flags)
int	botan_pk_op_sign_destroy (botan_pk_op_sign_t op)
int	botan_pk_op_sign_finish (botan_pk_op_sign_t op, botan_rng_t rng, uint8_t sig[], size_t *sig_len)
int	botan_pk_op_sign_output_length (botan_pk_op_sign_t op, size_t *olen)
int	botan_pk_op_sign_update (botan_pk_op_sign_t op, const uint8_t in[], size_t in_len)
int	botan_pk_op_verify_create (botan_pk_op_verify_t *op, botan_pubkey_t key, const char *hash_and_padding, uint32_t flags)
int	botan_pk_op_verify_destroy (botan_pk_op_verify_t op)
int	botan_pk_op_verify_finish (botan_pk_op_verify_t op, const uint8_t sig[], size_t sig_len)
int	botan_pk_op_verify_update (botan_pk_op_verify_t op, const uint8_t in[], size_t in_len)
int	botan_pkcs_hash_id (const char *hash_name, uint8_t pkcs_id[], size_t *pkcs_id_len)
int	botan_privkey_algo_name (botan_privkey_t key, char out[], size_t *out_len)
int	botan_privkey_check_key (botan_privkey_t key, botan_rng_t rng, uint32_t flags)
int	botan_privkey_create (botan_privkey_t *key, const char *algo_name, const char *algo_params, botan_rng_t rng)
int	botan_privkey_create_dh (botan_privkey_t *key, botan_rng_t rng, const char *param)
int	botan_privkey_create_ecdh (botan_privkey_t *key, botan_rng_t rng, const char *params)
int	botan_privkey_create_ecdsa (botan_privkey_t *key, botan_rng_t rng, const char *params)
int	botan_privkey_create_mceliece (botan_privkey_t *key, botan_rng_t rng, size_t n, size_t t)
int	botan_privkey_create_rsa (botan_privkey_t *key, botan_rng_t rng, size_t n_bits)
int	botan_privkey_destroy (botan_privkey_t key)
int	botan_privkey_dsa_get_x (botan_mp_t n, botan_privkey_t key)
int	botan_privkey_ed25519_get_privkey (botan_privkey_t key, uint8_t output[64])
int	botan_privkey_ed448_get_privkey (botan_privkey_t key, uint8_t output[57])
int	botan_privkey_export (botan_privkey_t key, uint8_t out[], size_t *out_len, uint32_t flags)
int	botan_privkey_export_encrypted (botan_privkey_t key, uint8_t out[], size_t *out_len, botan_rng_t rng, const char *passphrase, const char *encryption_algo, uint32_t flags)
int	botan_privkey_export_encrypted_pbkdf_iter (botan_privkey_t key, uint8_t out[], size_t *out_len, botan_rng_t rng, const char *passphrase, size_t pbkdf_iterations, const char *cipher_algo, const char *pbkdf_algo, uint32_t flags)
int	botan_privkey_export_encrypted_pbkdf_msec (botan_privkey_t key, uint8_t out[], size_t *out_len, botan_rng_t rng, const char *passphrase, uint32_t pbkdf_msec_runtime, size_t *pbkdf_iterations_out, const char *cipher_algo, const char *pbkdf_algo, uint32_t flags)
int	botan_privkey_export_pubkey (botan_pubkey_t *out, botan_privkey_t in)
int	botan_privkey_get_field (botan_mp_t output, botan_privkey_t key, const char *field_name)
int	botan_privkey_load (botan_privkey_t *key, botan_rng_t rng, const uint8_t bits[], size_t len, const char *password)
int	botan_privkey_load_classic_mceliece (botan_privkey_t *key, const uint8_t privkey[], size_t key_len, const char *cmce_mode)
int	botan_privkey_load_dh (botan_privkey_t *key, botan_mp_t p, botan_mp_t g, botan_mp_t x)
int	botan_privkey_load_dsa (botan_privkey_t *key, botan_mp_t p, botan_mp_t q, botan_mp_t g, botan_mp_t x)
int	botan_privkey_load_ecdh (botan_privkey_t *key, botan_mp_t scalar, const char *curve_name)
int	botan_privkey_load_ecdsa (botan_privkey_t *key, botan_mp_t scalar, const char *curve_name)
int	botan_privkey_load_ed25519 (botan_privkey_t *key, const uint8_t privkey[32])
int	botan_privkey_load_ed448 (botan_privkey_t *key, const uint8_t privkey[57])
int	botan_privkey_load_frodokem (botan_privkey_t *key, const uint8_t privkey[], size_t key_len, const char *frodo_mode)
int	botan_privkey_load_kyber (botan_privkey_t *key, const uint8_t privkey[], size_t key_len)
int	botan_privkey_load_ml_dsa (botan_privkey_t *key, const uint8_t privkey[], size_t key_len, const char *mldsa_mode)
int	botan_privkey_load_ml_kem (botan_privkey_t *key, const uint8_t privkey[], size_t key_len, const char *mlkem_mode)
int	botan_privkey_load_rsa (botan_privkey_t *key, botan_mp_t p, botan_mp_t q, botan_mp_t e)
int	botan_privkey_load_rsa_pkcs1 (botan_privkey_t *key, const uint8_t bits[], size_t len)
int	botan_privkey_load_slh_dsa (botan_privkey_t *key, const uint8_t privkey[], size_t key_len, const char *slhdsa_mode)
int	botan_privkey_load_sm2 (botan_privkey_t *key, botan_mp_t scalar, const char *curve_name)
int	botan_privkey_load_sm2_enc (botan_privkey_t *key, botan_mp_t scalar, const char *curve_name)
int	botan_privkey_load_x25519 (botan_privkey_t *key, const uint8_t privkey[32])
int	botan_privkey_load_x448 (botan_privkey_t *key, const uint8_t privkey[56])
int	botan_privkey_oid (botan_asn1_oid_t *oid, botan_privkey_t key)
int	botan_privkey_remaining_operations (botan_privkey_t key, uint64_t *out)
int	botan_privkey_rsa_get_d (botan_mp_t d, botan_privkey_t rsa_key)
int	botan_privkey_rsa_get_e (botan_mp_t e, botan_privkey_t rsa_key)
int	botan_privkey_rsa_get_n (botan_mp_t n, botan_privkey_t rsa_key)
int	botan_privkey_rsa_get_p (botan_mp_t p, botan_privkey_t rsa_key)
int	botan_privkey_rsa_get_privkey (botan_privkey_t rsa_key, uint8_t out[], size_t *out_len, uint32_t flags)
int	botan_privkey_rsa_get_q (botan_mp_t q, botan_privkey_t rsa_key)
int	botan_privkey_stateful_operation (botan_privkey_t key, int *out)
int	botan_privkey_view_der (botan_privkey_t key, botan_view_ctx ctx, botan_view_bin_fn view)
int	botan_privkey_view_encrypted_der (botan_privkey_t key, botan_rng_t rng, const char *passphrase, const char *cipher_algo, const char *pbkdf_algo, size_t pbkdf_iterations, botan_view_ctx ctx, botan_view_bin_fn view)
int	botan_privkey_view_encrypted_der_timed (botan_privkey_t key, botan_rng_t rng, const char *passphrase, const char *cipher_algo, const char *pbkdf_algo, size_t pbkdf_runtime_msec, botan_view_ctx ctx, botan_view_bin_fn view)
int	botan_privkey_view_encrypted_pem (botan_privkey_t key, botan_rng_t rng, const char *passphrase, const char *cipher_algo, const char *pbkdf_algo, size_t pbkdf_iterations, botan_view_ctx ctx, botan_view_str_fn view)
int	botan_privkey_view_encrypted_pem_timed (botan_privkey_t key, botan_rng_t rng, const char *passphrase, const char *cipher_algo, const char *pbkdf_algo, size_t pbkdf_runtime_msec, botan_view_ctx ctx, botan_view_str_fn view)
int	botan_privkey_view_kyber_raw_key (botan_privkey_t key, botan_view_ctx ctx, botan_view_bin_fn view)
int	botan_privkey_view_pem (botan_privkey_t key, botan_view_ctx ctx, botan_view_str_fn view)
int	botan_privkey_view_raw (botan_privkey_t key, botan_view_ctx ctx, botan_view_bin_fn view)
int	botan_privkey_x25519_get_privkey (botan_privkey_t key, uint8_t output[32])
int	botan_privkey_x448_get_privkey (botan_privkey_t key, uint8_t output[56])
int	botan_pubkey_algo_name (botan_pubkey_t key, char out[], size_t *out_len)
int	botan_pubkey_check_key (botan_pubkey_t key, botan_rng_t rng, uint32_t flags)
int	botan_pubkey_destroy (botan_pubkey_t key)
int	botan_pubkey_dsa_get_g (botan_mp_t d, botan_pubkey_t key)
int	botan_pubkey_dsa_get_p (botan_mp_t p, botan_pubkey_t key)
int	botan_pubkey_dsa_get_q (botan_mp_t q, botan_pubkey_t key)
int	botan_pubkey_dsa_get_y (botan_mp_t y, botan_pubkey_t key)
int	botan_pubkey_ecc_key_used_explicit_encoding (botan_pubkey_t key)
int	botan_pubkey_ed25519_get_pubkey (botan_pubkey_t key, uint8_t pubkey[32])
int	botan_pubkey_ed448_get_pubkey (botan_pubkey_t key, uint8_t pubkey[57])
int	botan_pubkey_estimated_strength (botan_pubkey_t key, size_t *estimate)
int	botan_pubkey_export (botan_pubkey_t key, uint8_t out[], size_t *out_len, uint32_t flags)
int	botan_pubkey_fingerprint (botan_pubkey_t key, const char *hash, uint8_t out[], size_t *out_len)
int	botan_pubkey_get_field (botan_mp_t output, botan_pubkey_t key, const char *field_name)
int	botan_pubkey_load (botan_pubkey_t *key, const uint8_t bits[], size_t len)
int	botan_pubkey_load_classic_mceliece (botan_pubkey_t *key, const uint8_t pubkey[], size_t key_len, const char *cmce_mode)
int	botan_pubkey_load_dsa (botan_pubkey_t *key, botan_mp_t p, botan_mp_t q, botan_mp_t g, botan_mp_t y)
int	botan_pubkey_load_ecdh (botan_pubkey_t *key, botan_mp_t public_x, botan_mp_t public_y, const char *curve_name)
int	botan_pubkey_load_ecdh_sec1 (botan_pubkey_t *key, const uint8_t sec1[], size_t sec1_len, const char *curve_name)
int	botan_pubkey_load_ecdsa (botan_pubkey_t *key, botan_mp_t public_x, botan_mp_t public_y, const char *curve_name)
int	botan_pubkey_load_ecdsa_sec1 (botan_pubkey_t *key, const uint8_t sec1[], size_t sec1_len, const char *curve_name)
int	botan_pubkey_load_ed25519 (botan_pubkey_t *key, const uint8_t pubkey[32])
int	botan_pubkey_load_ed448 (botan_pubkey_t *key, const uint8_t pubkey[57])
int	botan_pubkey_load_frodokem (botan_pubkey_t *key, const uint8_t pubkey[], size_t key_len, const char *frodo_mode)
int	botan_pubkey_load_kyber (botan_pubkey_t *key, const uint8_t pubkey[], size_t key_len)
int	botan_pubkey_load_ml_dsa (botan_pubkey_t *key, const uint8_t pubkey[], size_t key_len, const char *mldsa_mode)
int	botan_pubkey_load_ml_kem (botan_pubkey_t *key, const uint8_t pubkey[], size_t key_len, const char *mlkem_mode)
int	botan_pubkey_load_rsa (botan_pubkey_t *key, botan_mp_t n, botan_mp_t e)
int	botan_pubkey_load_rsa_pkcs1 (botan_pubkey_t *key, const uint8_t bits[], size_t len)
int	botan_pubkey_load_slh_dsa (botan_pubkey_t *key, const uint8_t pubkey[], size_t key_len, const char *slhdsa_mode)
int	botan_pubkey_load_sm2 (botan_pubkey_t *key, botan_mp_t public_x, botan_mp_t public_y, const char *curve_name)
int	botan_pubkey_load_sm2_enc (botan_pubkey_t *key, botan_mp_t public_x, botan_mp_t public_y, const char *curve_name)
int	botan_pubkey_load_sm2_sec1 (botan_pubkey_t *key, const uint8_t sec1[], size_t sec1_len, const char *curve_name)
int	botan_pubkey_load_x25519 (botan_pubkey_t *key, const uint8_t pubkey[32])
int	botan_pubkey_load_x448 (botan_pubkey_t *key, const uint8_t pubkey[56])
int	botan_pubkey_oid (botan_asn1_oid_t *oid, botan_pubkey_t key)
int	botan_pubkey_rsa_get_e (botan_mp_t e, botan_pubkey_t rsa_key)
int	botan_pubkey_rsa_get_n (botan_mp_t n, botan_pubkey_t rsa_key)
int	botan_pubkey_sm2_compute_za (uint8_t out[], size_t *out_len, const char *ident, const char *hash_algo, botan_pubkey_t key)
int	botan_pubkey_view_der (botan_pubkey_t key, botan_view_ctx ctx, botan_view_bin_fn view)
int	botan_pubkey_view_ec_public_point (botan_pubkey_t key, botan_view_ctx ctx, botan_view_bin_fn view)
int	botan_pubkey_view_kyber_raw_key (botan_pubkey_t key, botan_view_ctx ctx, botan_view_bin_fn view)
int	botan_pubkey_view_pem (botan_pubkey_t key, botan_view_ctx ctx, botan_view_str_fn view)
int	botan_pubkey_view_raw (botan_pubkey_t key, botan_view_ctx ctx, botan_view_bin_fn view)
int	botan_pubkey_x25519_get_pubkey (botan_pubkey_t key, uint8_t pubkey[32])
int	botan_pubkey_x448_get_pubkey (botan_pubkey_t key, uint8_t pubkey[56])
int	botan_pwdhash (const char *algo, size_t param1, size_t param2, size_t param3, uint8_t out[], size_t out_len, const char *passphrase, size_t passphrase_len, const uint8_t salt[], size_t salt_len)
int	botan_pwdhash_timed (const char *algo, uint32_t msec, size_t *param1, size_t *param2, size_t *param3, uint8_t out[], size_t out_len, const char *passphrase, size_t passphrase_len, const uint8_t salt[], size_t salt_len)
int	botan_rng_add_entropy (botan_rng_t rng, const uint8_t *entropy, size_t entropy_len)
int	botan_rng_destroy (botan_rng_t rng)
int	botan_rng_generate_with_input (botan_rng_t rng, uint8_t *out, size_t out_len, const uint8_t *addl_input, size_t addl_len)
int	botan_rng_get (botan_rng_t rng, uint8_t *out, size_t out_len)
int	botan_rng_init (botan_rng_t *rng, const char *rng_type)
int	botan_rng_init_custom (botan_rng_t *rng_out, const char *rng_name, void *context, int(*get_cb)(void *context, uint8_t *out, size_t out_len), int(*add_entropy_cb)(void *context, const uint8_t input[], size_t length), void(*destroy_cb)(void *context))
int	botan_rng_init_drbg (botan_rng_t *rng_out, const char *drbg_name, const uint8_t *seed, size_t seed_len)
int	botan_rng_reseed (botan_rng_t rng, size_t bits)
int	botan_rng_reseed_from_rng (botan_rng_t rng, botan_rng_t source_rng, size_t bits)
int	botan_same_mem (const uint8_t *x, const uint8_t *y, size_t len)
int	botan_scrub_mem (void *mem, size_t bytes)
int	botan_scrypt (uint8_t out[], size_t out_len, const char *passphrase, const uint8_t salt[], size_t salt_len, size_t N, size_t r, size_t p)
int	botan_srp6_client_agree (const char *username, const char *password, const char *group_id, const char *hash_id, const uint8_t salt[], size_t salt_len, const uint8_t B[], size_t B_len, botan_rng_t rng_obj, uint8_t A[], size_t *A_len, uint8_t K[], size_t *K_len)
int	botan_srp6_generate_verifier (const char *identifier, const char *password, const uint8_t salt[], size_t salt_len, const char *group_id, const char *hash_id, uint8_t verifier[], size_t *verifier_len)
int	botan_srp6_group_size (const char *group_id, size_t *group_p_bytes)
int	botan_srp6_server_session_destroy (botan_srp6_server_session_t srp6)
int	botan_srp6_server_session_init (botan_srp6_server_session_t *srp6)
int	botan_srp6_server_session_step1 (botan_srp6_server_session_t srp6, const uint8_t verifier[], size_t verifier_len, const char *group_id, const char *hash_id, botan_rng_t rng_obj, uint8_t B_pub[], size_t *B_pub_len)
int	botan_srp6_server_session_step2 (botan_srp6_server_session_t srp6, const uint8_t A[], size_t A_len, uint8_t key[], size_t *key_len)
int	botan_system_rng_get (uint8_t *out, size_t out_len)
int	botan_totp_check (botan_totp_t totp, uint32_t totp_code, uint64_t timestamp, size_t acceptable_clock_drift)
int	botan_totp_destroy (botan_totp_t totp)
int	botan_totp_generate (botan_totp_t totp, uint32_t *totp_code, uint64_t timestamp)
int	botan_totp_init (botan_totp_t *totp, const uint8_t key[], size_t key_len, const char *hash_algo, size_t digits, size_t time_step)
int	botan_tpm2_crypto_backend_state_destroy (botan_tpm2_crypto_backend_state_t cbs)
int	botan_tpm2_ctx_destroy (botan_tpm2_ctx_t ctx)
int	botan_tpm2_ctx_enable_crypto_backend (botan_tpm2_ctx_t ctx, botan_rng_t rng)
int	botan_tpm2_ctx_from_esys (botan_tpm2_ctx_t *ctx_out, struct ESYS_CONTEXT *esys_ctx)
int	botan_tpm2_ctx_init (botan_tpm2_ctx_t *ctx_out, const char *tcti_nameconf)
int	botan_tpm2_ctx_init_ex (botan_tpm2_ctx_t *ctx_out, const char *tcti_name, const char *tcti_conf)
int	botan_tpm2_enable_crypto_backend (botan_tpm2_crypto_backend_state_t *cbs_out, struct ESYS_CONTEXT *esys_ctx, botan_rng_t rng)
int	botan_tpm2_rng_init (botan_rng_t *rng_out, botan_tpm2_ctx_t ctx, botan_tpm2_session_t s1, botan_tpm2_session_t s2, botan_tpm2_session_t s3)
int	botan_tpm2_session_destroy (botan_tpm2_session_t session)
int	botan_tpm2_supports_crypto_backend (void)
int	botan_tpm2_unauthenticated_session_init (botan_tpm2_session_t *session_out, botan_tpm2_ctx_t ctx)
uint32_t	botan_version_datestamp (void)
uint32_t	botan_version_major (void)
uint32_t	botan_version_minor (void)
uint32_t	botan_version_patch (void)
const char *	botan_version_string (void)
int	botan_x509_cert_allowed_extended_usage_oid (botan_x509_cert_t cert, botan_asn1_oid_t oid)
int	botan_x509_cert_allowed_extended_usage_str (botan_x509_cert_t cert, const char *oid)
int	botan_x509_cert_allowed_usage (botan_x509_cert_t cert, unsigned int key_usage)
int	botan_x509_cert_destroy (botan_x509_cert_t cert)
int	botan_x509_cert_dup (botan_x509_cert_t *new_cert, botan_x509_cert_t cert)
int	botan_x509_cert_excluded_name_constraints (botan_x509_cert_t cert, size_t index, botan_x509_general_name_t *constraint)
int	botan_x509_cert_excluded_name_constraints_count (botan_x509_cert_t cert, size_t *count)
int	botan_x509_cert_get_authority_key_id (botan_x509_cert_t cert, uint8_t out[], size_t *out_len)
int	botan_x509_cert_get_fingerprint (botan_x509_cert_t cert, const char *hash, uint8_t out[], size_t *out_len)
int	botan_x509_cert_get_issuer_dn (botan_x509_cert_t cert, const char *key, size_t index, uint8_t out[], size_t *out_len)
int	botan_x509_cert_get_issuer_dn_count (botan_x509_cert_t cert, const char *key, size_t *count)
int	botan_x509_cert_get_path_length_constraint (botan_x509_cert_t cert, size_t *path_limit)
int	botan_x509_cert_get_public_key (botan_x509_cert_t cert, botan_pubkey_t *key)
int	botan_x509_cert_get_public_key_bits (botan_x509_cert_t cert, uint8_t out[], size_t *out_len)
int	botan_x509_cert_get_serial_number (botan_x509_cert_t cert, uint8_t out[], size_t *out_len)
int	botan_x509_cert_get_subject_dn (botan_x509_cert_t cert, const char *key, size_t index, uint8_t out[], size_t *out_len)
int	botan_x509_cert_get_subject_dn_count (botan_x509_cert_t cert, const char *key, size_t *count)
int	botan_x509_cert_get_subject_key_id (botan_x509_cert_t cert, uint8_t out[], size_t *out_len)
int	botan_x509_cert_get_time_expires (botan_x509_cert_t cert, char out[], size_t *out_len)
int	botan_x509_cert_get_time_starts (botan_x509_cert_t cert, char out[], size_t *out_len)
int	botan_x509_cert_hostname_match (botan_x509_cert_t cert, const char *hostname)
int	botan_x509_cert_is_ca (botan_x509_cert_t cert)
int	botan_x509_cert_issuer_alternative_names (botan_x509_cert_t cert, size_t index, botan_x509_general_name_t *alt_name)
int	botan_x509_cert_issuer_alternative_names_count (botan_x509_cert_t cert, size_t *count)
int	botan_x509_cert_load (botan_x509_cert_t *cert_obj, const uint8_t cert[], size_t cert_len)
int	botan_x509_cert_load_file (botan_x509_cert_t *cert_obj, const char *filename)
int	botan_x509_cert_not_after (botan_x509_cert_t cert, uint64_t *time_since_epoch)
int	botan_x509_cert_not_before (botan_x509_cert_t cert, uint64_t *time_since_epoch)
int	botan_x509_cert_permitted_name_constraints (botan_x509_cert_t cert, size_t index, botan_x509_general_name_t *constraint)
int	botan_x509_cert_permitted_name_constraints_count (botan_x509_cert_t cert, size_t *count)
int	botan_x509_cert_serial_number (botan_x509_cert_t cert, botan_mp_t *serial_number)
int	botan_x509_cert_subject_alternative_names (botan_x509_cert_t cert, size_t index, botan_x509_general_name_t *alt_name)
int	botan_x509_cert_subject_alternative_names_count (botan_x509_cert_t cert, size_t *count)
int	botan_x509_cert_to_string (botan_x509_cert_t cert, char out[], size_t *out_len)
const char *	botan_x509_cert_validation_status (int code)
int	botan_x509_cert_verify (int *validation_result, botan_x509_cert_t cert, const botan_x509_cert_t *intermediates, size_t intermediates_len, const botan_x509_cert_t *trusted, size_t trusted_len, const char *trusted_path, size_t required_strength, const char *hostname, uint64_t reference_time)
int	botan_x509_cert_verify_with_crl (int *validation_result, botan_x509_cert_t cert, const botan_x509_cert_t *intermediates, size_t intermediates_len, const botan_x509_cert_t *trusted, size_t trusted_len, const botan_x509_crl_t *crls, size_t crls_len, const char *trusted_path, size_t required_strength, const char *hostname, uint64_t reference_time)
int	botan_x509_cert_view_as_string (botan_x509_cert_t cert, botan_view_ctx ctx, botan_view_str_fn view)
int	botan_x509_cert_view_binary_values (botan_x509_cert_t cert, botan_x509_value_type value_type, size_t index, botan_view_ctx ctx, botan_view_bin_fn view)
int	botan_x509_cert_view_binary_values_count (botan_x509_cert_t cert, botan_x509_value_type value_type, size_t *count)
int	botan_x509_cert_view_public_key_bits (botan_x509_cert_t cert, botan_view_ctx ctx, botan_view_bin_fn view)
int	botan_x509_cert_view_string_values (botan_x509_cert_t cert, botan_x509_value_type value_type, size_t index, botan_view_ctx ctx, botan_view_str_fn view)
int	botan_x509_cert_view_string_values_count (botan_x509_cert_t cert, botan_x509_value_type value_type, size_t *count)
int	botan_x509_crl_create (botan_x509_crl_t *crl_obj, botan_rng_t rng, botan_x509_cert_t ca_cert, botan_privkey_t ca_key, uint64_t issue_time, uint32_t next_update, const char *hash_fn, const char *padding)
int	botan_x509_crl_destroy (botan_x509_crl_t crl)
int	botan_x509_crl_entries (botan_x509_crl_t crl, size_t index, botan_x509_crl_entry_t *entry)
int	botan_x509_crl_entries_count (botan_x509_crl_t crl, size_t *count)
int	botan_x509_crl_entry_create (botan_x509_crl_entry_t *entry, botan_x509_cert_t cert, int reason_code)
int	botan_x509_crl_entry_destroy (botan_x509_crl_entry_t entry)
int	botan_x509_crl_entry_reason (botan_x509_crl_entry_t entry, int *reason_code)
int	botan_x509_crl_entry_revocation_date (botan_x509_crl_entry_t entry, uint64_t *time_since_epoch)
int	botan_x509_crl_entry_serial_number (botan_x509_crl_entry_t entry, botan_mp_t *serial_number)
int	botan_x509_crl_entry_view_serial_number (botan_x509_crl_entry_t entry, botan_view_ctx ctx, botan_view_bin_fn view)
int	botan_x509_crl_load (botan_x509_crl_t *crl_obj, const uint8_t crl_bits[], size_t crl_bits_len)
int	botan_x509_crl_load_file (botan_x509_crl_t *crl_obj, const char *crl_path)
int	botan_x509_crl_next_update (botan_x509_crl_t crl, uint64_t *time_since_epoch)
int	botan_x509_crl_this_update (botan_x509_crl_t crl, uint64_t *time_since_epoch)
int	botan_x509_crl_update (botan_x509_crl_t *crl_obj, botan_x509_crl_t last_crl, botan_rng_t rng, botan_x509_cert_t ca_cert, botan_privkey_t ca_key, uint64_t issue_time, uint32_t next_update, const botan_x509_crl_entry_t *new_entries, size_t new_entries_len, const char *hash_fn, const char *padding)
int	botan_x509_crl_verify_signature (botan_x509_crl_t crl, botan_pubkey_t key)
int	botan_x509_crl_view_binary_values (botan_x509_crl_t crl_obj, botan_x509_value_type value_type, size_t index, botan_view_ctx ctx, botan_view_bin_fn view)
int	botan_x509_crl_view_binary_values_count (botan_x509_crl_t crl_obj, botan_x509_value_type value_type, size_t *count)
int	botan_x509_crl_view_string_values (botan_x509_crl_t crl_obj, botan_x509_value_type value_type, size_t index, botan_view_ctx ctx, botan_view_str_fn view)
int	botan_x509_crl_view_string_values_count (botan_x509_crl_t crl_obj, botan_x509_value_type value_type, size_t *count)
int	botan_x509_general_name_destroy (botan_x509_general_name_t alt_names)
int	botan_x509_general_name_get_type (botan_x509_general_name_t name, unsigned int *type)
int	botan_x509_general_name_view_binary_value (botan_x509_general_name_t name, botan_view_ctx ctx, botan_view_bin_fn view)
int	botan_x509_general_name_view_string_value (botan_x509_general_name_t name, botan_view_ctx ctx, botan_view_str_fn view)
int	botan_x509_is_revoked (botan_x509_crl_t crl, botan_x509_cert_t cert)
int	botan_xof_accepts_input (botan_xof_t xof)
int	botan_xof_block_size (botan_xof_t xof, size_t *block_size)
int	botan_xof_clear (botan_xof_t xof)
int	botan_xof_copy_state (botan_xof_t *dest, botan_xof_t source)
int	botan_xof_destroy (botan_xof_t xof)
int	botan_xof_init (botan_xof_t *xof, const char *xof_name, uint32_t flags)
int	botan_xof_name (botan_xof_t xof, char *name, size_t *name_len)
int	botan_xof_output (botan_xof_t xof, uint8_t *out, size_t out_len)
int	botan_xof_update (botan_xof_t xof, const uint8_t *in, size_t in_len)
int	botan_zfec_decode (size_t K, size_t N, const size_t *indexes, uint8_t *const *inputs, size_t shareSize, uint8_t **outputs)
int	botan_zfec_encode (size_t K, size_t N, const uint8_t *input, size_t size, uint8_t **outputs)

Detailed Description

Public Header.

Definition in file ffi.h.

Macro Definition Documentation

BOTAN_CHECK_KEY_EXPENSIVE_TESTS

#define BOTAN_CHECK_KEY_EXPENSIVE_TESTS   1

Definition at line 1587 of file ffi.h.

Referenced by botan_privkey_check_key(), and botan_pubkey_check_key().

BOTAN_CIPHER_INIT_FLAG_DECRYPT

#define BOTAN_CIPHER_INIT_FLAG_DECRYPT   1

Definition at line 670 of file ffi.h.

BOTAN_CIPHER_INIT_FLAG_ENCRYPT

#define BOTAN_CIPHER_INIT_FLAG_ENCRYPT   0

Definition at line 669 of file ffi.h.

Referenced by botan_cipher_init().

BOTAN_CIPHER_INIT_FLAG_MASK_DIRECTION

#define BOTAN_CIPHER_INIT_FLAG_MASK_DIRECTION   1

Definition at line 668 of file ffi.h.

Referenced by botan_cipher_init().

BOTAN_CIPHER_UPDATE_FLAG_FINAL

#define BOTAN_CIPHER_UPDATE_FLAG_FINAL   (1U << 0)

Definition at line 763 of file ffi.h.

Referenced by botan_cipher_update().

BOTAN_FFI_API_VERSION

#define BOTAN_FFI_API_VERSION   20260506

The compile time API version. This matches the value of botan_ffi_api_version. This can be used for compile-time checking if a particular feature is available.

Note this same value is also reflected in BOTAN_HAS_FFI in build.h, however that declaration is not visible here since this header is intentionally free-standing, depending only on a few C standard library headers.

Definition at line 73 of file ffi.h.

BOTAN_FFI_DEPRECATED

#define BOTAN_FFI_DEPRECATED

(

msg

)

Definition at line 106 of file ffi.h.

BOTAN_FFI_EXPORT

#define BOTAN_FFI_EXPORT	(		maj,
			min )

BOTAN_FFI_EXPORT indicates public FFI functions.

The arguments to the macro are to indicate the version that that particular FFI function was first available

Definition at line 91 of file ffi.h.

Referenced by botan_srp6_server_session_step1().

BOTAN_FFI_HEX_LOWER_CASE

#define BOTAN_FFI_HEX_LOWER_CASE   1

Flag that can be provided to botan_hex_encode to request lower case hex

Definition at line 249 of file ffi.h.

Referenced by botan_hex_encode().

BOTAN_FPE_FLAG_FE1_COMPAT_MODE

#define BOTAN_FPE_FLAG_FE1_COMPAT_MODE   1

Definition at line 3008 of file ffi.h.

Referenced by botan_fpe_fe1_init().

BOTAN_PRIVKEY_EXPORT_FLAG_DER

#define BOTAN_PRIVKEY_EXPORT_FLAG_DER   0

Definition at line 1657 of file ffi.h.

Referenced by botan_privkey_export(), botan_privkey_export_encrypted_pbkdf_iter(), botan_privkey_export_encrypted_pbkdf_msec(), botan_privkey_rsa_get_privkey(), and botan_pubkey_export().

BOTAN_PRIVKEY_EXPORT_FLAG_PEM

#define BOTAN_PRIVKEY_EXPORT_FLAG_PEM   1

Definition at line 1658 of file ffi.h.

Referenced by botan_privkey_export(), botan_privkey_export_encrypted_pbkdf_iter(), botan_privkey_export_encrypted_pbkdf_msec(), botan_privkey_rsa_get_privkey(), and botan_pubkey_export().

BOTAN_PRIVKEY_EXPORT_FLAG_RAW

#define BOTAN_PRIVKEY_EXPORT_FLAG_RAW   2

Definition at line 1659 of file ffi.h.

Referenced by botan_privkey_export(), and botan_pubkey_export().

BOTAN_PUBKEY_DER_FORMAT_SIGNATURE

#define BOTAN_PUBKEY_DER_FORMAT_SIGNATURE   1

Definition at line 2223 of file ffi.h.

Referenced by botan_pk_op_encrypt_create(), botan_pk_op_sign_create(), and botan_pk_op_verify_create().

Typedef Documentation

botan_asn1_oid_t

typedef struct botan_asn1_oid_struct* botan_asn1_oid_t

Definition at line 1253 of file ffi.h.

botan_block_cipher_t

typedef struct botan_block_cipher_struct* botan_block_cipher_t

Definition at line 966 of file ffi.h.

botan_cipher_t

typedef struct botan_cipher_struct* botan_cipher_t

Definition at line 666 of file ffi.h.

botan_ec_group_t

typedef struct botan_ec_group_struct* botan_ec_group_t

Definition at line 1302 of file ffi.h.

botan_ec_point_t

typedef struct botan_ec_point_struct* botan_ec_point_t

Definition at line 1447 of file ffi.h.

botan_ec_scalar_t

typedef struct botan_ec_scalar_struct* botan_ec_scalar_t

Definition at line 1446 of file ffi.h.

botan_fpe_t

typedef struct botan_fpe_struct* botan_fpe_t

Format Preserving Encryption

Definition at line 3006 of file ffi.h.

botan_hash_t

typedef struct botan_hash_struct* botan_hash_t

Definition at line 490 of file ffi.h.

botan_hotp_t

typedef struct botan_hotp_struct* botan_hotp_t

HOTP

Definition at line 2934 of file ffi.h.

botan_mac_t

typedef struct botan_mac_struct* botan_mac_t

Definition at line 570 of file ffi.h.

botan_mp_t

typedef struct botan_mp_struct* botan_mp_t

Definition at line 1032 of file ffi.h.

botan_pk_op_decrypt_t

typedef struct botan_pk_op_decrypt_struct* botan_pk_op_decrypt_t

Definition at line 2202 of file ffi.h.

botan_pk_op_encrypt_t

typedef struct botan_pk_op_encrypt_struct* botan_pk_op_encrypt_t

Definition at line 2178 of file ffi.h.

botan_pk_op_ka_t

typedef struct botan_pk_op_ka_struct* botan_pk_op_ka_t

Definition at line 2264 of file ffi.h.

botan_pk_op_kem_decrypt_t

typedef struct botan_pk_op_kem_decrypt_struct* botan_pk_op_kem_decrypt_t

Definition at line 2323 of file ffi.h.

botan_pk_op_kem_encrypt_t

typedef struct botan_pk_op_kem_encrypt_struct* botan_pk_op_kem_encrypt_t

Definition at line 2293 of file ffi.h.

botan_pk_op_sign_t

typedef struct botan_pk_op_sign_struct* botan_pk_op_sign_t

Definition at line 2225 of file ffi.h.

botan_pk_op_verify_t

typedef struct botan_pk_op_verify_struct* botan_pk_op_verify_t

Definition at line 2245 of file ffi.h.

botan_privkey_t

typedef struct botan_privkey_struct* botan_privkey_t

Definition at line 1564 of file ffi.h.

botan_pubkey_t

typedef struct botan_pubkey_struct* botan_pubkey_t

Definition at line 1797 of file ffi.h.

botan_rng_t

typedef struct botan_rng_struct* botan_rng_t

RNG type

Definition at line 291 of file ffi.h.

botan_srp6_server_session_t

typedef struct botan_srp6_server_session_struct* botan_srp6_server_session_t

SRP-6 Server Session type

Definition at line 3029 of file ffi.h.

botan_totp_t

typedef struct botan_totp_struct* botan_totp_t

TOTP

Definition at line 2966 of file ffi.h.

botan_tpm2_crypto_backend_state_t

typedef struct botan_tpm2_crypto_backend_state_struct* botan_tpm2_crypto_backend_state_t

TPM2 crypto backend state object

Definition at line 3197 of file ffi.h.

botan_tpm2_ctx_t

typedef struct botan_tpm2_ctx_struct* botan_tpm2_ctx_t

TPM2 context

Definition at line 3187 of file ffi.h.

botan_tpm2_session_t

typedef struct botan_tpm2_session_struct* botan_tpm2_session_t

TPM2 session

Definition at line 3192 of file ffi.h.

botan_view_bin_fn

typedef int(* botan_view_bin_fn) (botan_view_ctx view_ctx, const uint8_t *data, size_t len)

Viewer function for binary data

Parameters

view_ctx	some application context
data	the binary data
len	the length of data in bytes

Definition at line 163 of file ffi.h.

botan_view_ctx

typedef void* botan_view_ctx

The application provided context for a view function

Definition at line 154 of file ffi.h.

botan_view_str_fn

typedef int(* botan_view_str_fn) (botan_view_ctx view_ctx, const char *str, size_t len)

Viewer function for string data

Parameters

view_ctx	some application context
str	the null terminated string
len	the length of string including the null terminator

Definition at line 172 of file ffi.h.

botan_x509_cert_t

typedef struct botan_x509_cert_struct* botan_x509_cert_t

Definition at line 2387 of file ffi.h.

botan_x509_crl_entry_t

typedef struct botan_x509_crl_entry_struct* botan_x509_crl_entry_t

Definition at line 2702 of file ffi.h.

botan_x509_crl_t

typedef struct botan_x509_crl_struct* botan_x509_crl_t

Definition at line 2701 of file ffi.h.

botan_x509_general_name_t

typedef struct botan_x509_general_name_struct* botan_x509_general_name_t

Definition at line 2570 of file ffi.h.

botan_xof_t

typedef struct botan_xof_struct* botan_xof_t

Definition at line 412 of file ffi.h.

Enumeration Type Documentation

BOTAN_FFI_ERROR

enum BOTAN_FFI_ERROR

Error codes

If you add a new value here be sure to also add it in botan_error_description

Enumerator
BOTAN_FFI_SUCCESS
BOTAN_FFI_INVALID_VERIFIER
BOTAN_FFI_ERROR_INVALID_INPUT
BOTAN_FFI_ERROR_BAD_MAC
BOTAN_FFI_ERROR_NO_VALUE
BOTAN_FFI_ERROR_INSUFFICIENT_BUFFER_SPACE
BOTAN_FFI_ERROR_STRING_CONVERSION_ERROR
BOTAN_FFI_ERROR_EXCEPTION_THROWN
BOTAN_FFI_ERROR_OUT_OF_MEMORY
BOTAN_FFI_ERROR_SYSTEM_ERROR
BOTAN_FFI_ERROR_INTERNAL_ERROR
BOTAN_FFI_ERROR_BAD_FLAG
BOTAN_FFI_ERROR_NULL_POINTER
BOTAN_FFI_ERROR_BAD_PARAMETER
BOTAN_FFI_ERROR_KEY_NOT_SET
BOTAN_FFI_ERROR_INVALID_KEY_LENGTH
BOTAN_FFI_ERROR_INVALID_OBJECT_STATE
BOTAN_FFI_ERROR_OUT_OF_RANGE
BOTAN_FFI_ERROR_NOT_IMPLEMENTED
BOTAN_FFI_ERROR_INVALID_OBJECT
BOTAN_FFI_ERROR_TLS_ERROR
BOTAN_FFI_ERROR_HTTP_ERROR
BOTAN_FFI_ERROR_ROUGHTIME_ERROR
BOTAN_FFI_ERROR_TPM_ERROR
BOTAN_FFI_ERROR_UNKNOWN_ERROR

Definition at line 115 of file ffi.h.

                       {
   BOTAN_FFI_SUCCESS = 0,
 
   BOTAN_FFI_INVALID_VERIFIER = 1,
 
   BOTAN_FFI_ERROR_INVALID_INPUT = -1,
   BOTAN_FFI_ERROR_BAD_MAC = -2,
   BOTAN_FFI_ERROR_NO_VALUE = -3,
 
   BOTAN_FFI_ERROR_INSUFFICIENT_BUFFER_SPACE = -10,
   BOTAN_FFI_ERROR_STRING_CONVERSION_ERROR = -11,
 
   BOTAN_FFI_ERROR_EXCEPTION_THROWN = -20,
   BOTAN_FFI_ERROR_OUT_OF_MEMORY = -21,
   BOTAN_FFI_ERROR_SYSTEM_ERROR = -22,
   BOTAN_FFI_ERROR_INTERNAL_ERROR = -23,
 
   BOTAN_FFI_ERROR_BAD_FLAG = -30,
   BOTAN_FFI_ERROR_NULL_POINTER = -31,
   BOTAN_FFI_ERROR_BAD_PARAMETER = -32,
   BOTAN_FFI_ERROR_KEY_NOT_SET = -33,
   BOTAN_FFI_ERROR_INVALID_KEY_LENGTH = -34,
   BOTAN_FFI_ERROR_INVALID_OBJECT_STATE = -35,
   BOTAN_FFI_ERROR_OUT_OF_RANGE = -36,
 
   BOTAN_FFI_ERROR_NOT_IMPLEMENTED = -40,
   BOTAN_FFI_ERROR_INVALID_OBJECT = -50,
 
   BOTAN_FFI_ERROR_TLS_ERROR = -75,
   BOTAN_FFI_ERROR_HTTP_ERROR = -76,
   BOTAN_FFI_ERROR_ROUGHTIME_ERROR = -77,
   BOTAN_FFI_ERROR_TPM_ERROR = -78,
 
   BOTAN_FFI_ERROR_UNKNOWN_ERROR = -100,
};

botan_x509_cert_key_constraints

enum botan_x509_cert_key_constraints

Enumerator
NO_CONSTRAINTS
DIGITAL_SIGNATURE
NON_REPUDIATION
KEY_ENCIPHERMENT
DATA_ENCIPHERMENT
KEY_AGREEMENT
KEY_CERT_SIGN
CRL_SIGN
ENCIPHER_ONLY
DECIPHER_ONLY

Definition at line 2529 of file ffi.h.

                                       {
   NO_CONSTRAINTS = 0,
   DIGITAL_SIGNATURE = 32768,
   NON_REPUDIATION = 16384,
   KEY_ENCIPHERMENT = 8192,
   DATA_ENCIPHERMENT = 4096,
   KEY_AGREEMENT = 2048,
   KEY_CERT_SIGN = 1024,
   CRL_SIGN = 512,
   ENCIPHER_ONLY = 256,
   DECIPHER_ONLY = 128
};

botan_x509_crl_reason_code

enum botan_x509_crl_reason_code

Enumerator
BOTAN_CRL_ENTRY_UNSPECIFIED
BOTAN_CRL_ENTRY_KEY_COMPROMISE
BOTAN_CRL_ENTRY_CA_COMPROMISE
BOTAN_CRL_ENTRY_AFFILIATION_CHANGED
BOTAN_CRL_ENTRY_SUPERSEDED
BOTAN_CRL_ENTRY_CESSATION_OF_OPERATION
BOTAN_CRL_ENTRY_CERTIFICATE_HOLD
BOTAN_CRL_ENTRY_REMOVE_FROM_CRL
BOTAN_CRL_ENTRY_PRIVILEGE_WITHDRAWN
BOTAN_CRL_ENTRY_AA_COMPROMISE

Definition at line 2733 of file ffi.h.

                                  {
   BOTAN_CRL_ENTRY_UNSPECIFIED = 0,
   BOTAN_CRL_ENTRY_KEY_COMPROMISE = 1,
   BOTAN_CRL_ENTRY_CA_COMPROMISE = 2,
   BOTAN_CRL_ENTRY_AFFILIATION_CHANGED = 3,
   BOTAN_CRL_ENTRY_SUPERSEDED = 4,
   BOTAN_CRL_ENTRY_CESSATION_OF_OPERATION = 5,
   BOTAN_CRL_ENTRY_CERTIFICATE_HOLD = 6,
   BOTAN_CRL_ENTRY_REMOVE_FROM_CRL = 8,
   BOTAN_CRL_ENTRY_PRIVILEGE_WITHDRAWN = 9,
   BOTAN_CRL_ENTRY_AA_COMPROMISE = 10
};

botan_x509_general_name_types

enum botan_x509_general_name_types

GeneralName type identifiers as defined in RFC 5280 A.2 (GeneralName ::= CHOICE) Type identifiers that are omitted here are (currently) not supported. Also, there is currently no way to access OTHER_NAME values via the FFI.

Enumerator
BOTAN_X509_OTHER_NAME
BOTAN_X509_EMAIL_ADDRESS
BOTAN_X509_DNS_NAME
BOTAN_X509_DIRECTORY_NAME
BOTAN_X509_URI
BOTAN_X509_IP_ADDRESS

Definition at line 2577 of file ffi.h.

                                     {
   BOTAN_X509_OTHER_NAME = 0,
   BOTAN_X509_EMAIL_ADDRESS = 1,
   BOTAN_X509_DNS_NAME = 2,
   BOTAN_X509_DIRECTORY_NAME = 4,
   BOTAN_X509_URI = 6,
   BOTAN_X509_IP_ADDRESS = 7,
};

botan_x509_value_type

enum botan_x509_value_type

Generic values that may be retrieved from X.509 certificates or CRLs via the generic getter functions.

When extending this list the existing entries must stay backward-compatible to remain ABI compatible across versions. Therefore, new values must be added to the end of this list.

See:

• botan_x509_cert_view_binary_values()
• botan_x509_crl_view_binary_values()
• botan_x509_cert_view_string_values()

Enumerator
BOTAN_X509_SERIAL_NUMBER
BOTAN_X509_SUBJECT_DN_BITS	singleton binary big-endian encoding
BOTAN_X509_ISSUER_DN_BITS	singleton binary DER encoding of the subject distinguished name
BOTAN_X509_SUBJECT_KEY_IDENTIFIER	singleton binary DER encoding of the issuer distinguished name
BOTAN_X509_AUTHORITY_KEY_IDENTIFIER	singleton binary encoding
BOTAN_X509_PUBLIC_KEY_PKCS8_BITS	singleton binary encoding
BOTAN_X509_TBS_DATA_BITS	singleton binary DER encoding of the PKCS#8 public key
BOTAN_X509_SIGNATURE_SCHEME_BITS	singleton binary DER encoding
BOTAN_X509_SIGNATURE_BITS	singleton binary DER encoding of the algorithm identifier
BOTAN_X509_DER_ENCODING	singleton binary signature bits
BOTAN_X509_PEM_ENCODING	singleton binary DER encoding of the whole object
BOTAN_X509_CRL_DISTRIBUTION_URLS	singleton string value PEM encoding of the whole object
BOTAN_X509_OCSP_RESPONDER_URLS	multi-value string of the CRL distribution points
BOTAN_X509_CA_ISSUERS_URLS	multi-value string of the OCSP responder URLs

Definition at line 2402 of file ffi.h.

               {
   BOTAN_X509_SERIAL_NUMBER = 0,            /** singleton binary big-endian encoding */
   BOTAN_X509_SUBJECT_DN_BITS = 1,          /** singleton binary DER encoding of the subject distinguished name */
   BOTAN_X509_ISSUER_DN_BITS = 2,           /** singleton binary DER encoding of the issuer distinguished name */
   BOTAN_X509_SUBJECT_KEY_IDENTIFIER = 3,   /** singleton binary encoding */
   BOTAN_X509_AUTHORITY_KEY_IDENTIFIER = 4, /** singleton binary encoding */
 
   BOTAN_X509_PUBLIC_KEY_PKCS8_BITS = 200, /** singleton binary DER encoding of the PKCS#8 public key */
   BOTAN_X509_TBS_DATA_BITS = 201,         /** singleton binary DER encoding */
   BOTAN_X509_SIGNATURE_SCHEME_BITS = 202, /** singleton binary DER encoding of the algorithm identifier */
   BOTAN_X509_SIGNATURE_BITS = 203,        /** singleton binary signature bits */
 
   BOTAN_X509_DER_ENCODING = 300, /** singleton binary DER encoding of the whole object */
   BOTAN_X509_PEM_ENCODING = 301, /** singleton string value PEM encoding of the whole object */
 
   BOTAN_X509_CRL_DISTRIBUTION_URLS = 400, /** multi-value string of the CRL distribution points */
   BOTAN_X509_OCSP_RESPONDER_URLS = 401,   /** multi-value string of the OCSP responder URLs */
   BOTAN_X509_CA_ISSUERS_URLS = 402,       /** multi-value string of the CA issuer URLs */
} botan_x509_value_type;

Function Documentation

botan_base64_decode()

int botan_base64_decode	(	const char *	base64_str,
		size_t	in_len,
		uint8_t *	out,
		size_t *	out_len )

Perform base64 decoding

Definition at line 370 of file ffi.cpp.

                                                                                              {
   if(any_null_pointers(out, out_len, base64_str)) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
 
   return ffi_guard_thunk(__func__, [=]() -> int {
      if(*out_len < Botan::base64_decode_max_output(in_len)) {
         *out_len = Botan::base64_decode_max_output(in_len);
         return BOTAN_FFI_ERROR_INSUFFICIENT_BUFFER_SPACE;
      }
 
      *out_len = Botan::base64_decode(out, std::string(base64_str, in_len));
      return BOTAN_FFI_SUCCESS;
   });
}

References Botan_FFI::any_null_pointers(), Botan::base64_decode(), Botan::base64_decode_max_output(), BOTAN_FFI_ERROR_INSUFFICIENT_BUFFER_SPACE, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_SUCCESS, and Botan_FFI::ffi_guard_thunk().

botan_base64_encode()

int botan_base64_encode	(	const uint8_t *	x,
		size_t	len,
		char *	out,
		size_t *	out_len )

Perform base64 encoding

Parameters

x	the input data
len	the length of x
out	the output buffer
out_len	the size of the output buffer on input, set to the number of bytes written

Returns

0 on success, a negative value on failure

Definition at line 360 of file ffi.cpp.

                                                                                   {
   if(len > 0 && in == nullptr) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
   return ffi_guard_thunk(__func__, [=]() -> int {
      const std::string base64 = Botan::base64_encode(in, len);
      return Botan_FFI::write_str_output(out, out_len, base64);
   });
}

References Botan::base64_encode(), BOTAN_FFI_ERROR_NULL_POINTER, Botan_FFI::ffi_guard_thunk(), and Botan_FFI::write_str_output().

botan_bcrypt_generate()

int botan_bcrypt_generate	(	uint8_t *	out,
		size_t *	out_len,
		const char *	password,
		botan_rng_t	rng,
		size_t	work_factor,
		uint32_t	flags )

Create a password hash using Bcrypt

Parameters

out	buffer holding the password hash, should be of length 64 bytes
out_len	the desired output length in bytes
password	the password
Random Number Generators	a random number generator
work_factor	how much work to do to slow down guessing attacks
flags	should be 0 in current API revision, all other uses are reserved and return BOTAN_FFI_ERROR_BAD_FLAG

Returns

0 on success, a negative value on failure

Output is formatted bcrypt $2a$...

TOD(Botan4) this should use char for the type of out

Definition at line 177 of file ffi_kdf.cpp.

                                                                                                    {
#if defined(BOTAN_HAS_BCRYPT)
   return ffi_guard_thunk(__func__, [=]() -> int {
      if(out == nullptr || out_len == nullptr || pass == nullptr) {
         return BOTAN_FFI_ERROR_NULL_POINTER;
      }
 
      if(flags != 0) {
         return BOTAN_FFI_ERROR_BAD_FLAG;
      }
 
      if(wf < 4 || wf > 18) {
         return BOTAN_FFI_ERROR_BAD_PARAMETER;
      }
 
      if(*out_len < 61) {
         *out_len = 61;
         return BOTAN_FFI_ERROR_INSUFFICIENT_BUFFER_SPACE;
      }
 
      Botan::RandomNumberGenerator& rng = safe_get(rng_obj);
      const std::string bcrypt = Botan::generate_bcrypt(pass, rng, static_cast<uint16_t>(wf));
      // TODO(Botan4) change the type of out and remove this cast
      return write_str_output(reinterpret_cast<char*>(out), out_len, bcrypt);
   });
#else
   BOTAN_UNUSED(out, out_len, pass, rng_obj, wf, flags);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References BOTAN_FFI_ERROR_BAD_FLAG, BOTAN_FFI_ERROR_BAD_PARAMETER, BOTAN_FFI_ERROR_INSUFFICIENT_BUFFER_SPACE, BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_UNUSED, Botan_FFI::ffi_guard_thunk(), Botan::generate_bcrypt(), Botan_FFI::safe_get(), and Botan_FFI::write_str_output().

botan_bcrypt_is_valid()

int botan_bcrypt_is_valid	(	const char *	pass,
		const char *	hash )

Check a previously created password hash

Parameters

pass	the password to check against
Hashes	the stored hash to check against

Returns

0 if if this password/hash combination is valid, 1 if the combination is not valid (but otherwise well formed), negative on error

Definition at line 209 of file ffi_kdf.cpp.

                                                              {
   if(any_null_pointers(pass, hash)) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
#if defined(BOTAN_HAS_BCRYPT)
   return ffi_guard_thunk(__func__, [=]() -> int {
      return Botan::check_bcrypt(pass, hash) ? BOTAN_FFI_SUCCESS : BOTAN_FFI_INVALID_VERIFIER;
   });
#else
   BOTAN_UNUSED(pass, hash);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References Botan_FFI::any_null_pointers(), BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_INVALID_VERIFIER, BOTAN_FFI_SUCCESS, BOTAN_UNUSED, Botan::check_bcrypt(), and Botan_FFI::ffi_guard_thunk().

botan_block_cipher_block_size()

int botan_block_cipher_block_size

(

botan_block_cipher_t

bc

)

Return the positive block size of this block cipher, or negative to indicate an error

Definition at line 60 of file ffi_block.cpp.

                                                           {
   return BOTAN_FFI_VISIT(bc, [](const auto& b) { return static_cast<int>(b.block_size()); });
}

References BOTAN_FFI_VISIT.

botan_block_cipher_clear()

int botan_block_cipher_clear

(

botan_block_cipher_t

bc

)

Reinitializes the block cipher

Returns

0 on success, a negative value on failure

Definition at line 42 of file ffi_block.cpp.

                                                      {
   return BOTAN_FFI_VISIT(bc, [](auto& b) { b.clear(); });
}

References BOTAN_FFI_VISIT.

botan_block_cipher_decrypt_blocks()

int botan_block_cipher_decrypt_blocks	(	botan_block_cipher_t	bc,
		const uint8_t	in[],
		uint8_t	out[],
		size_t	blocks )

Decrypt one or more blocks with the cipher

Definition at line 71 of file ffi_block.cpp.

                                                                                                                 {
   if(in == nullptr || out == nullptr) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
   return BOTAN_FFI_VISIT(bc, [=](const auto& b) { b.decrypt_n(in, out, blocks); });
}

References BOTAN_FFI_ERROR_NULL_POINTER, and BOTAN_FFI_VISIT.

botan_block_cipher_destroy()

int botan_block_cipher_destroy

(

botan_block_cipher_t

bc

)

Destroy a block cipher object

Returns

0 if success, error if invalid object handle

Destroy a block cipher object

Definition at line 38 of file ffi_block.cpp.

                                                        {
   return BOTAN_FFI_CHECKED_DELETE(bc);
}

References BOTAN_FFI_CHECKED_DELETE.

botan_block_cipher_encrypt_blocks()

int botan_block_cipher_encrypt_blocks	(	botan_block_cipher_t	bc,
		const uint8_t	in[],
		uint8_t	out[],
		size_t	blocks )

Encrypt one or more blocks with the cipher

Definition at line 64 of file ffi_block.cpp.

                                                                                                                 {
   if(in == nullptr || out == nullptr) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
   return BOTAN_FFI_VISIT(bc, [=](const auto& b) { b.encrypt_n(in, out, blocks); });
}

References BOTAN_FFI_ERROR_NULL_POINTER, and BOTAN_FFI_VISIT.

botan_block_cipher_get_keyspec()

int botan_block_cipher_get_keyspec	(	botan_block_cipher_t	cipher,
		size_t *	out_minimum_keylength,
		size_t *	out_maximum_keylength,
		size_t *	out_keylength_modulo )

Get the key length limits of this block cipher

Parameters

cipher	the object to read
out_minimum_keylength	if non-NULL, will be set to minimum keylength of cipher
out_maximum_keylength	if non-NULL, will be set to maximum keylength of cipher
out_keylength_modulo	if non-NULL will be set to byte multiple of valid keys

Definition at line 86 of file ffi_block.cpp.

                                                                 {
   return BOTAN_FFI_VISIT(cipher, [=](const auto& bc) {
      if(out_minimum_keylength) {
         *out_minimum_keylength = bc.minimum_keylength();
      }
      if(out_maximum_keylength) {
         *out_maximum_keylength = bc.maximum_keylength();
      }
      if(out_keylength_modulo) {
         *out_keylength_modulo = bc.key_spec().keylength_multiple();
      }
   });
}

References BOTAN_FFI_VISIT.

botan_block_cipher_init()

int botan_block_cipher_init	(	botan_block_cipher_t *	bc,
		const char *	cipher_name )

Initialize a block cipher object

Definition at line 18 of file ffi_block.cpp.

                                                                           {
   return ffi_guard_thunk(__func__, [=]() -> int {
      if(bc == nullptr || bc_name == nullptr || *bc_name == 0) {
         return BOTAN_FFI_ERROR_NULL_POINTER;
      }
 
      *bc = nullptr;
 
      auto cipher = Botan::BlockCipher::create(bc_name);
      if(cipher == nullptr) {
         return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
      }
 
      return ffi_new_object(bc, std::move(cipher));
   });
}

References BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, Botan::BlockCipher::create(), Botan_FFI::ffi_guard_thunk(), and Botan_FFI::ffi_new_object().

botan_block_cipher_name()

int botan_block_cipher_name	(	botan_block_cipher_t	cipher,
		char *	name,
		size_t *	name_len )

Get the name of this block cipher

Parameters

cipher	the object to read
name	output buffer
name_len	on input, the length of buffer, on success the number of bytes written

Definition at line 78 of file ffi_block.cpp.

                                                                                       {
   if(name_len == nullptr) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
 
   return BOTAN_FFI_VISIT(cipher, [=](const auto& bc) { return write_str_output(name, name_len, bc.name()); });
}

References BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_VISIT, and Botan_FFI::write_str_output().

botan_block_cipher_set_key()

int botan_block_cipher_set_key	(	botan_block_cipher_t	bc,
		const uint8_t	key[],
		size_t	len )

Set the key for a block cipher instance

Definition at line 49 of file ffi_block.cpp.

                                                                                         {
   if(key == nullptr) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
   return BOTAN_FFI_VISIT(bc, [=](auto& b) { b.set_key(key, len); });
}

References BOTAN_FFI_ERROR_NULL_POINTER, and BOTAN_FFI_VISIT.

botan_cipher_clear()

int botan_cipher_clear

(

botan_cipher_t

hash

)

Reset the key, nonce, AD and all other state on this cipher object

Definition at line 123 of file ffi_cipher.cpp.

                                              {
   return BOTAN_FFI_VISIT(cipher, [=](auto& c) {
      cipher->buf().clear();
      c.clear();
   });
}

References BOTAN_FFI_VISIT.

botan_cipher_destroy()

int botan_cipher_destroy

(

botan_cipher_t

cipher

)

Destroy the cipher object

Returns

0 if success, error if invalid object handle

Definition at line 119 of file ffi_cipher.cpp.

                                                {
   return BOTAN_FFI_CHECKED_DELETE(cipher);
}

References BOTAN_FFI_CHECKED_DELETE.

botan_cipher_get_default_nonce_length()

int botan_cipher_get_default_nonce_length	(	botan_cipher_t	cipher,
		size_t *	nl )

Get the default nonce length of this cipher

Definition at line 324 of file ffi_cipher.cpp.

                                                                             {
   if(nl == nullptr) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
   return BOTAN_FFI_VISIT(cipher, [=](const auto& c) { *nl = c.default_nonce_length(); });
}

References BOTAN_FFI_ERROR_NULL_POINTER, and BOTAN_FFI_VISIT.

botan_cipher_get_ideal_update_granularity()

int botan_cipher_get_ideal_update_granularity	(	botan_cipher_t	cipher,
		size_t *	ug )

Return the ideal update granularity of the cipher. This is some multiple of the update granularity, reflecting possibilities for optimization.

Definition at line 338 of file ffi_cipher.cpp.

                                                                                 {
   if(ug == nullptr) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
   return BOTAN_FFI_VISIT(cipher, [=](const auto& c) { *ug = c.ideal_granularity(); });
}

References BOTAN_FFI_ERROR_NULL_POINTER, and BOTAN_FFI_VISIT.

botan_cipher_get_keyspec()

int botan_cipher_get_keyspec	(	botan_cipher_t	cipher,
		size_t *	min_keylen,
		size_t *	max_keylen,
		size_t *	mod_keylen )

Get information about the supported key lengths.

Definition at line 156 of file ffi_cipher.cpp.

                                                           {
   return BOTAN_FFI_VISIT(cipher, [=](const auto& c) {
      if(out_minimum_keylength) {
         *out_minimum_keylength = c.key_spec().minimum_keylength();
      }
      if(out_maximum_keylength) {
         *out_maximum_keylength = c.key_spec().maximum_keylength();
      }
      if(out_keylength_modulo) {
         *out_keylength_modulo = c.key_spec().keylength_multiple();
      }
   });
}

References BOTAN_FFI_VISIT.

botan_cipher_get_tag_length()

int botan_cipher_get_tag_length	(	botan_cipher_t	cipher,
		size_t *	tag_size )

Get the tag length of the cipher (0 for non-AEAD modes)

Definition at line 345 of file ffi_cipher.cpp.

                                                                   {
   if(tl == nullptr) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
   return BOTAN_FFI_VISIT(cipher, [=](const auto& c) { *tl = c.tag_size(); });
}

References BOTAN_FFI_ERROR_NULL_POINTER, and BOTAN_FFI_VISIT.

botan_cipher_get_update_granularity()

int botan_cipher_get_update_granularity	(	botan_cipher_t	cipher,
		size_t *	ug )

Return the update granularity of the cipher; botan_cipher_update must be called with blocks of this size, except for the final.

Definition at line 331 of file ffi_cipher.cpp.

                                                                           {
   if(ug == nullptr) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
   return BOTAN_FFI_VISIT(cipher, [=](const auto& /*c*/) { *ug = cipher->update_size(); });
}

References BOTAN_FFI_ERROR_NULL_POINTER, and BOTAN_FFI_VISIT.

botan_cipher_init()

int botan_cipher_init	(	botan_cipher_t *	cipher,
		const char *	name,
		uint32_t	flags )

Initialize a cipher object

Definition at line 99 of file ffi_cipher.cpp.

                                                                                       {
   return ffi_guard_thunk(__func__, [=]() -> int {
      if(any_null_pointers(cipher, cipher_name)) {
         return BOTAN_FFI_ERROR_NULL_POINTER;
      }
      const bool encrypt_p = ((flags & BOTAN_CIPHER_INIT_FLAG_MASK_DIRECTION) == BOTAN_CIPHER_INIT_FLAG_ENCRYPT);
      const Botan::Cipher_Dir dir = encrypt_p ? Botan::Cipher_Dir::Encryption : Botan::Cipher_Dir::Decryption;
 
      std::unique_ptr<Botan::Cipher_Mode> mode(Botan::Cipher_Mode::create(cipher_name, dir));
      if(!mode) {
         return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
      }
 
      const size_t update_size = ffi_choose_update_size(*mode);
      const size_t ideal_update_size = std::max(mode->ideal_granularity(), update_size);
 
      return ffi_new_object(cipher, std::move(mode), update_size, ideal_update_size);
   });
}

References Botan_FFI::any_null_pointers(), BOTAN_CIPHER_INIT_FLAG_ENCRYPT, BOTAN_CIPHER_INIT_FLAG_MASK_DIRECTION, BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, Botan::Cipher_Mode::create(), Botan::Decryption, Botan::Encryption, Botan_FFI::ffi_guard_thunk(), and Botan_FFI::ffi_new_object().

botan_cipher_is_authenticated()

int botan_cipher_is_authenticated

(

botan_cipher_t

cipher

)

Returns 1 iff the cipher provides authentication as well as confidentiality.

Definition at line 352 of file ffi_cipher.cpp.

                                                         {
   return BOTAN_FFI_VISIT(cipher, [=](const auto& c) { return c.authenticated() ? 1 : 0; });
}

References BOTAN_FFI_VISIT.

botan_cipher_name()

int botan_cipher_name	(	botan_cipher_t	cipher,
		char *	name,
		size_t *	name_len )

Return the name of the cipher object

Definition at line 360 of file ffi_cipher.cpp.

                                                                           {
   return BOTAN_FFI_VISIT(cipher, [=](const auto& c) { return write_str_output(name, name_len, c.name()); });
}

References BOTAN_FFI_VISIT, and Botan_FFI::write_str_output().

botan_cipher_output_length()

int botan_cipher_output_length	(	botan_cipher_t	cipher,
		size_t	in_len,
		size_t *	out_len )

Return the output length of this cipher, for a particular input length.

Definition at line 137 of file ffi_cipher.cpp.

                                                                                      {
   if(out_len == nullptr) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
 
   return BOTAN_FFI_VISIT(cipher, [=](const auto& c) { *out_len = c.output_length(in_len); });
}

References BOTAN_FFI_ERROR_NULL_POINTER, and BOTAN_FFI_VISIT.

botan_cipher_query_keylen()

int botan_cipher_query_keylen	(	botan_cipher_t	cipher,
		size_t *	out_minimum_keylength,
		size_t *	out_maximum_keylength )

Get information about the key lengths. Prefer botan_cipher_get_keyspec

Definition at line 145 of file ffi_cipher.cpp.

                                                                                                                   {
   return BOTAN_FFI_VISIT(cipher, [=](const auto& c) {
      if(out_minimum_keylength) {
         *out_minimum_keylength = c.key_spec().minimum_keylength();
      }
      if(out_maximum_keylength) {
         *out_maximum_keylength = c.key_spec().maximum_keylength();
      }
   });
}

References BOTAN_FFI_VISIT.

botan_cipher_requires_entire_message()

int botan_cipher_requires_entire_message

(

botan_cipher_t

cipher

)

Returns 1 iff the cipher requires the entire message before any encryption or decryption can be performed. No output data will be produced in botan_cipher_update() until the final flag is set.

Definition at line 356 of file ffi_cipher.cpp.

                                                                {
   return BOTAN_FFI_VISIT(cipher, [=](const auto& c) { return c.requires_entire_message() ? 1 : 0; });
}

References BOTAN_FFI_VISIT.

botan_cipher_reset()

int botan_cipher_reset

(

botan_cipher_t

cipher

)

Reset the message specific state for this cipher. Without resetting the keys, this resets the nonce, and any state associated with any message bits that have been processed so far.

It is conceptually equivalent to calling botan_cipher_clear followed by botan_cipher_set_key with the original key.

Definition at line 130 of file ffi_cipher.cpp.

                                              {
   return BOTAN_FFI_VISIT(cipher, [=](auto& c) {
      cipher->buf().clear();
      c.reset();
   });
}

References BOTAN_FFI_VISIT.

botan_cipher_set_associated_data()

int botan_cipher_set_associated_data	(	botan_cipher_t	cipher,
		const uint8_t *	ad,
		size_t	ad_len )

Set the associated data. Will fail if cipher is not an AEAD

Definition at line 310 of file ffi_cipher.cpp.

                                                                                              {
   return BOTAN_FFI_VISIT(cipher, [=](auto& c) {
      if(Botan::AEAD_Mode* aead = dynamic_cast<Botan::AEAD_Mode*>(&c)) {
         aead->set_associated_data(ad, ad_len);
         return BOTAN_FFI_SUCCESS;
      }
      return BOTAN_FFI_ERROR_BAD_PARAMETER;
   });
}

References BOTAN_FFI_ERROR_BAD_PARAMETER, BOTAN_FFI_SUCCESS, and BOTAN_FFI_VISIT.

botan_cipher_set_key()

int botan_cipher_set_key	(	botan_cipher_t	cipher,
		const uint8_t *	key,
		size_t	key_len )

Set the key for this cipher object

Definition at line 173 of file ffi_cipher.cpp.

                                                                                    {
   if(key_len > 0 && key == nullptr) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
   return BOTAN_FFI_VISIT(cipher, [=](auto& c) { c.set_key(key, key_len); });
}

References BOTAN_FFI_ERROR_NULL_POINTER, and BOTAN_FFI_VISIT.

botan_cipher_start()

int botan_cipher_start	(	botan_cipher_t	cipher,
		const uint8_t *	nonce,
		size_t	nonce_len )

Begin processing a new message using the provided nonce

Definition at line 180 of file ffi_cipher.cpp.

                                                                                          {
   return ffi_guard_thunk(__func__, [=]() -> int {
      Botan::Cipher_Mode& cipher = safe_get(cipher_obj);
      cipher.start(nonce, nonce_len);
      return BOTAN_FFI_SUCCESS;
   });
}

References BOTAN_FFI_SUCCESS, Botan_FFI::ffi_guard_thunk(), Botan_FFI::safe_get(), and Botan::Cipher_Mode::start().

botan_cipher_update()

int botan_cipher_update	(	botan_cipher_t	cipher,
		uint32_t	flags,
		uint8_t	output[],
		size_t	output_size,
		size_t *	output_written,
		const uint8_t	input_bytes[],
		size_t	input_size,
		size_t *	input_consumed )

Encrypt/Decrypt some data and/or finalize the encryption/decryption.

This encrypts as many bytes from input_bytes into output_bytes as possible. Unless BOTAN_CIPHER_UPDATE_FLAG_FINAL is set, this function will consume bytes in multiples of botan_cipher_get_update_granularity(). input_consumed and output_written will be set accordingly and it is the caller's responsibility to adapt their buffers accordingly before calling this function again. Note that, unless BOTAN_CIPHER_UPDATE_FLAG_FINAL is set, the cipher will at most generate input_size output bytes.

Eventually, the caller must set the BOTAN_CIPHER_UPDATE_FLAG_FINAL flag to indicate that no more input will be provided. This will cause the cipher to consume all given input bytes and produce the final output; or return a BOTAN_FFI_ERROR_INSUFFICIENT_BUFFER_SPACE error if the given output buffer was too small. In the latter case, output_written will be set to the required buffer size. Calling again with BOTAN_CIPHER_UPDATE_FLAG_FINAL, a big enough buffer and no further input will then produce the final output.

Note that some ciphers require the entire message to be provided before any output is produced.

See also

botan_cipher_requires_entire_message().

Definition at line 188 of file ffi_cipher.cpp.

                                                {
   if(any_null_pointers(output_written, input_consumed)) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
 
   return ffi_guard_thunk(__func__, [=]() -> int {
      using namespace Botan;
      Cipher_Mode& cipher = safe_get(cipher_obj);
      secure_vector<uint8_t>& mbuf = cipher_obj->buf();
 
      // If the cipher object's internal buffer contains residual data from
      // a previous invocation, we can be sure that botan_cipher_update() was
      // called with the final flag set but not enough buffer space was provided
      // to accommodate the final output.
      const bool was_finished_before = !mbuf.empty();
      const bool final_input = (flags & BOTAN_CIPHER_UPDATE_FLAG_FINAL) != 0;
 
      // Bring the output variables into a defined state.
      *output_written = 0;
      *input_consumed = 0;
 
      // Once the final flag was set once, it must always be set for
      // consecutive invocations.
      if(was_finished_before && !final_input) {
         return BOTAN_FFI_ERROR_INVALID_OBJECT_STATE;
      }
 
      // If the final flag was set in a previous invocation, no more input
      // data can be processed.
      if(was_finished_before && input_size > 0) {
         return BOTAN_FFI_ERROR_BAD_PARAMETER;
      }
 
      // Make sure that we always clear the internal buffer before returning
      // or aborting this invocation due to an exception.
      auto clean_buffer = scoped_cleanup([&mbuf] { mbuf.clear(); });
 
      if(final_input) {
         // If the final flag is set for the first time, we need to process the
         // remaining input data and then finalize the cipher object.
         if(!was_finished_before) {
            *input_consumed = input_size;
            mbuf.resize(input_size);
            copy_mem(mbuf, std::span(input, input_size));
 
            try {
               cipher.finish(mbuf);
            } catch(Invalid_Authentication_Tag&) {
               return BOTAN_FFI_ERROR_BAD_MAC;
            }
         }
 
         // At this point, the cipher object is finalized (potentially in a
         // previous invocation) and we can copy the final output to the caller.
         *output_written = mbuf.size();
 
         // Not enough space to copy the final output out to the caller.
         // Inform them how much space we need for a successful operation.
         if(output_size < mbuf.size()) {
            // This is the only place where mbuf is not cleared before returning.
            clean_buffer.disengage();
            return BOTAN_FFI_ERROR_INSUFFICIENT_BUFFER_SPACE;
         }
 
         // Copy the final output to the caller, mbuf is cleared afterwards.
         copy_mem(std::span(output, mbuf.size()), mbuf);
      } else {
         // Process data in a streamed fashion without finalizing. No data is
         // ever retained in the cipher object's internal buffer. If we run out
         // of either input data or output capacity, we stop and report that not
         // all bytes were processed via *output_written and *input_consumed.
 
         BufferSlicer in({input, input_size});
         BufferStuffer out({output, output_size});
 
         // Helper function to do blockwise processing of data.
         auto blockwise_update = [&](const size_t granularity) {
            if(granularity == 0) {
               return;
            }
 
            const size_t expected_output_per_iteration = cipher.requires_entire_message() ? 0 : granularity;
            mbuf.resize(granularity);
 
            while(in.remaining() >= granularity && out.remaining_capacity() >= expected_output_per_iteration) {
               copy_mem(mbuf, in.take(granularity));
               const auto written_bytes = cipher.process(mbuf);
               BOTAN_DEBUG_ASSERT(written_bytes == expected_output_per_iteration);
               if(written_bytes > 0) {
                  BOTAN_ASSERT_NOMSG(written_bytes <= granularity);
                  copy_mem(out.next(written_bytes), std::span(mbuf).first(written_bytes));
               }
            }
         };
 
         // First, process as much data as possible in chunks of ideal granularity
         blockwise_update(cipher_obj->ideal_update_size());
 
         // Then process the remaining bytes in chunks of update_size() or, in one go
         // if update_size() is equal to 1 --> i.e. likely a stream cipher.
         const bool is_stream_cipher = (cipher_obj->update_size() == 1);
         const size_t tail_granularity =
            is_stream_cipher ? std::min(in.remaining(), out.remaining_capacity()) : cipher_obj->update_size();
         BOTAN_DEBUG_ASSERT(tail_granularity < cipher_obj->ideal_update_size());
         blockwise_update(tail_granularity);
 
         // Inform the caller about the amount of data processed.
         *output_written = output_size - out.remaining_capacity();
         *input_consumed = input_size - in.remaining();
      }
 
      return BOTAN_FFI_SUCCESS;
   });
}

References Botan_FFI::any_null_pointers(), BOTAN_ASSERT_NOMSG, BOTAN_CIPHER_UPDATE_FLAG_FINAL, BOTAN_DEBUG_ASSERT, BOTAN_FFI_ERROR_BAD_MAC, BOTAN_FFI_ERROR_BAD_PARAMETER, BOTAN_FFI_ERROR_INSUFFICIENT_BUFFER_SPACE, BOTAN_FFI_ERROR_INVALID_OBJECT_STATE, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_SUCCESS, Botan::copy_mem(), Botan_FFI::ffi_guard_thunk(), Botan::Cipher_Mode::finish(), Botan::Cipher_Mode::process(), Botan::Cipher_Mode::requires_entire_message(), and Botan_FFI::safe_get().

botan_cipher_valid_nonce_length()

int botan_cipher_valid_nonce_length	(	botan_cipher_t	cipher,
		size_t	nl )

Return if the specified nonce length is valid for this cipher

Definition at line 320 of file ffi_cipher.cpp.

                                                                      {
   return BOTAN_FFI_VISIT(cipher, [=](const auto& c) { return c.valid_nonce_length(nl) ? 1 : 0; });
}

References BOTAN_FFI_VISIT.

botan_constant_time_compare()

int botan_constant_time_compare	(	const uint8_t *	x,
		const uint8_t *	y,
		size_t	len )

Returns 0 if x[0..len] == y[0..len], or otherwise -1

Definition at line 318 of file ffi.cpp.

                                                                                {
   if(len > 0 && any_null_pointers(x, y)) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
   auto same = Botan::CT::is_equal(x, y, len);
   // Return 0 if same or -1 otherwise
   return static_cast<int>(same.select(1, 0)) - 1;
}

References Botan_FFI::any_null_pointers(), BOTAN_FFI_ERROR_NULL_POINTER, and Botan::CT::is_equal().

Referenced by botan_same_mem().

botan_ec_group_destroy()

int botan_ec_group_destroy

(

botan_ec_group_t

ec_group

)

Returns

negative number on error, or zero on success

Definition at line 21 of file ffi_ec.cpp.

                                                      {
   return BOTAN_FFI_CHECKED_DELETE(ec_group);
}

References BOTAN_FFI_CHECKED_DELETE.

botan_ec_group_equal()

int botan_ec_group_equal	(	botan_ec_group_t	curve1,
		botan_ec_group_t	curve2 )

Returns

0 if curve1 != curve2

1 if curve1 == curve2

negative number on error

Definition at line 190 of file ffi_ec.cpp.

                                                                               {
   return BOTAN_FFI_VISIT(curve1_w, [=](const auto& curve1) -> int { return curve1 == safe_get(curve2_w); });
}

References BOTAN_FFI_VISIT, and Botan_FFI::safe_get().

botan_ec_group_from_ber()

int botan_ec_group_from_ber	(	botan_ec_group_t *	ec_group,
		const uint8_t *	ber,
		size_t	ber_len )

Decode a BER encoded ECC domain parameter set

Parameters

EC Group	the new object will be placed here
ber	encoding
ber_len	size of the encoding in bytes

Returns

negative number on error, or zero on success

Definition at line 72 of file ffi_ec.cpp.

                                                                                            {
   return ffi_guard_thunk(__func__, [=]() -> int {
      if(ec_group == nullptr || ber == nullptr) {
         return BOTAN_FFI_ERROR_NULL_POINTER;
      }
 
      Botan::EC_Group group(ber, ber_len);
 
      auto group_ptr = std::make_unique<Botan::EC_Group>(std::move(group));
      return ffi_new_object(ec_group, std::move(group_ptr));
   });
}

References BOTAN_FFI_ERROR_NULL_POINTER, Botan_FFI::ffi_guard_thunk(), and Botan_FFI::ffi_new_object().

botan_ec_group_from_name()

int botan_ec_group_from_name	(	botan_ec_group_t *	ec_group,
		const char *	name )

Initialize an EC Group from a common group name (eg "secp256r1")

Parameters

EC Group	the new object will be placed here
name	a known group name

Returns

negative number on error, or zero on success

Definition at line 111 of file ffi_ec.cpp.

                                                                           {
   return ffi_guard_thunk(__func__, [=]() -> int {
      if(ec_group == nullptr || name == nullptr) {
         return BOTAN_FFI_ERROR_NULL_POINTER;
      }
 
      Botan::EC_Group group = Botan::EC_Group::from_name(name);
 
      auto group_ptr = std::make_unique<Botan::EC_Group>(std::move(group));
      return ffi_new_object(ec_group, std::move(group_ptr));
   });
}

References BOTAN_FFI_ERROR_NULL_POINTER, Botan_FFI::ffi_guard_thunk(), Botan_FFI::ffi_new_object(), and Botan::EC_Group::from_name().

botan_ec_group_from_oid()

int botan_ec_group_from_oid	(	botan_ec_group_t *	ec_group,
		botan_asn1_oid_t	oid )

Initialize an EC Group from a group named by an object identifier

Parameters

EC Group	the new object will be placed here
oid	a known OID

Returns

negative number on error, or zero on success

Definition at line 98 of file ffi_ec.cpp.

                                                                              {
   return ffi_guard_thunk(__func__, [=]() -> int {
      if(ec_group == nullptr) {
         return BOTAN_FFI_ERROR_NULL_POINTER;
      }
 
      Botan::EC_Group group = Botan::EC_Group::from_OID(safe_get(oid));
 
      auto group_ptr = std::make_unique<Botan::EC_Group>(std::move(group));
      return ffi_new_object(ec_group, std::move(group_ptr));
   });
}

References BOTAN_FFI_ERROR_NULL_POINTER, Botan_FFI::ffi_guard_thunk(), Botan_FFI::ffi_new_object(), Botan::EC_Group::from_OID(), and Botan_FFI::safe_get().

botan_ec_group_from_params()

int botan_ec_group_from_params	(	botan_ec_group_t *	ec_group,
		botan_asn1_oid_t	oid,
		botan_mp_t	p,
		botan_mp_t	a,
		botan_mp_t	b,
		botan_mp_t	base_x,
		botan_mp_t	base_y,
		botan_mp_t	order )

Create a new EC Group from parameters

Warning

use only elliptic curve parameters that you trust

Parameters

EC Group	the new object will be placed here
p	the elliptic curve prime (at most 521 bits)
a	the elliptic curve a param
b	the elliptic curve b param
base_x	the x coordinate of the group generator
base_y	the y coordinate of the group generator
order	the order of the group

Returns

negative number on error, or zero on success

Definition at line 51 of file ffi_ec.cpp.

                                                 {
   return ffi_guard_thunk(__func__, [=]() -> int {
      if(ec_group == nullptr) {
         return BOTAN_FFI_ERROR_NULL_POINTER;
      }
 
      Botan::EC_Group group(
         safe_get(oid), safe_get(p), safe_get(a), safe_get(b), safe_get(base_x), safe_get(base_y), safe_get(order));
 
      auto group_ptr = std::make_unique<Botan::EC_Group>(std::move(group));
      return ffi_new_object(ec_group, std::move(group_ptr));
   });
}

References BOTAN_FFI_ERROR_NULL_POINTER, Botan_FFI::ffi_guard_thunk(), Botan_FFI::ffi_new_object(), and Botan_FFI::safe_get().

botan_ec_group_from_pem()

int botan_ec_group_from_pem	(	botan_ec_group_t *	ec_group,
		const char *	pem )

Initialize an EC Group from the PEM/ASN.1 encoding

Parameters

EC Group	the new object will be placed here
PEM	encoding

Returns

negative number on error, or zero on success

Definition at line 85 of file ffi_ec.cpp.

                                                                         {
   return ffi_guard_thunk(__func__, [=]() -> int {
      if(ec_group == nullptr || pem == nullptr) {
         return BOTAN_FFI_ERROR_NULL_POINTER;
      }
 
      Botan::EC_Group group = Botan::EC_Group::from_PEM(pem);
 
      auto group_ptr = std::make_unique<Botan::EC_Group>(std::move(group));
      return ffi_new_object(ec_group, std::move(group_ptr));
   });
}

References BOTAN_FFI_ERROR_NULL_POINTER, Botan_FFI::ffi_guard_thunk(), Botan_FFI::ffi_new_object(), and Botan::EC_Group::from_PEM().

botan_ec_group_get_a()

int botan_ec_group_get_a	(	botan_mp_t *	a,
		botan_ec_group_t	ec_group )

Get the a parameter of the elliptic curve equation

Definition at line 167 of file ffi_ec.cpp.

                                                                   {
   return botan_ec_group_get_component(a, ec_group, [](const auto& g) -> const Botan::BigInt& { return g.get_a(); });
}

botan_ec_group_get_b()

int botan_ec_group_get_b	(	botan_mp_t *	b,
		botan_ec_group_t	ec_group )

Get the b parameter of the elliptic curve equation

Definition at line 171 of file ffi_ec.cpp.

                                                                   {
   return botan_ec_group_get_component(b, ec_group, [](const auto& g) -> const Botan::BigInt& { return g.get_b(); });
}

botan_ec_group_get_curve_oid()

int botan_ec_group_get_curve_oid	(	botan_asn1_oid_t *	oid,
		botan_ec_group_t	ec_group )

Get the curve OID of an EC Group

Definition at line 139 of file ffi_ec.cpp.

                                                                                   {
   return BOTAN_FFI_VISIT(ec_group, [=](const auto& g) -> int {
      if(oid == nullptr) {
         return BOTAN_FFI_ERROR_NULL_POINTER;
      }
      auto oid_ptr = std::make_unique<Botan::OID>(g.get_curve_oid());
      return ffi_new_object(oid, std::move(oid_ptr));
   });
}

References BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_VISIT, and Botan_FFI::ffi_new_object().

botan_ec_group_get_g_x()

int botan_ec_group_get_g_x	(	botan_mp_t *	g_x,
		botan_ec_group_t	ec_group )

Get the x coordinate of the base point

Definition at line 175 of file ffi_ec.cpp.

                                                                       {
   return botan_ec_group_get_component(
      g_x, ec_group, [](const auto& g) -> const Botan::BigInt& { return g.get_g_x(); });
}

botan_ec_group_get_g_y()

int botan_ec_group_get_g_y	(	botan_mp_t *	g_y,
		botan_ec_group_t	ec_group )

Get the y coordinate of the base point

Definition at line 180 of file ffi_ec.cpp.

                                                                       {
   return botan_ec_group_get_component(
      g_y, ec_group, [](const auto& g) -> const Botan::BigInt& { return g.get_g_y(); });
}

botan_ec_group_get_order()

int botan_ec_group_get_order	(	botan_mp_t *	order,
		botan_ec_group_t	ec_group )

Get the order of the base point

Definition at line 185 of file ffi_ec.cpp.

                                                                           {
   return botan_ec_group_get_component(
      order, ec_group, [](const auto& g) -> const Botan::BigInt& { return g.get_order(); });
}

botan_ec_group_get_p()

int botan_ec_group_get_p	(	botan_mp_t *	p,
		botan_ec_group_t	ec_group )

Get the prime modulus of the field

Definition at line 163 of file ffi_ec.cpp.

                                                                   {
   return botan_ec_group_get_component(p, ec_group, [](const auto& g) -> const Botan::BigInt& { return g.get_p(); });
}

botan_ec_group_supports_application_specific_group()

int botan_ec_group_supports_application_specific_group

(

int *

out

)

Checks if in this build configuration it is possible to register an application specific elliptic curve and sets

Parameters

out	to 1 if so, 0 otherwise

Returns

0 on success, a negative value on failure

Definition at line 25 of file ffi_ec.cpp.

                                                                 {
   if(out == nullptr) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
   if(Botan::EC_Group::supports_application_specific_group()) {
      *out = 1;
   } else {
      *out = 0;
   }
   return BOTAN_FFI_SUCCESS;
}

References BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_SUCCESS, and Botan::EC_Group::supports_application_specific_group().

botan_ec_group_supports_named_group()

int botan_ec_group_supports_named_group	(	const char *	name,
		int *	out )

Checks if in this build configuration botan_ec_group_from_name(group_ptr, name) will succeed and sets

Parameters

out	to 1 if so, 0 otherwise.

Returns

negative number on error, or zero on success

Definition at line 37 of file ffi_ec.cpp.

                                                                    {
   return ffi_guard_thunk(__func__, [=]() -> int {
      if(name == nullptr || out == nullptr) {
         return BOTAN_FFI_ERROR_NULL_POINTER;
      }
      if(Botan::EC_Group::supports_named_group(name)) {
         *out = 1;
      } else {
         *out = 0;
      }
      return BOTAN_FFI_SUCCESS;
   });
}

References BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_SUCCESS, Botan_FFI::ffi_guard_thunk(), and Botan::EC_Group::supports_named_group().

botan_ec_group_unregister()

int botan_ec_group_unregister

(

botan_asn1_oid_t

oid

)

Unregister a previously registered group.

Parameters

oid	the oid associated with the group to unregister

Returns

1 if the group was found and unregistered, else 0

Using this is discouraged for normal use. This is only useful or necessary if you are registering a very large number of distinct groups, and need to worry about memory constraints.

Definition at line 124 of file ffi_ec.cpp.

                                                    {
   return BOTAN_FFI_VISIT(oid, [=](const auto& o) -> int { return Botan::EC_Group::unregister(o) ? 1 : 0; });
}

References BOTAN_FFI_VISIT, and Botan::EC_Group::unregister().

botan_ec_group_view_der()

int botan_ec_group_view_der	(	botan_ec_group_t	ec_group,
		botan_view_ctx	ctx,
		botan_view_bin_fn	view )

View an EC Group in DER encoding

Definition at line 128 of file ffi_ec.cpp.

                                                                                                   {
   return BOTAN_FFI_VISIT(ec_group,
                          [=](const auto& g) -> int { return invoke_view_callback(view, ctx, g.DER_encode()); });
}

References BOTAN_FFI_VISIT, and Botan_FFI::invoke_view_callback().

botan_ec_group_view_pem()

int botan_ec_group_view_pem	(	botan_ec_group_t	ec_group,
		botan_view_ctx	ctx,
		botan_view_str_fn	view )

View an EC Group in PEM encoding

Definition at line 133 of file ffi_ec.cpp.

                                                                                                   {
   return BOTAN_FFI_VISIT(ec_group, [=](const auto& g) -> int {
      return invoke_view_callback(view, ctx, g.PEM_encode(Botan::EC_Group_Encoding::NamedCurve));
   });
}

References BOTAN_FFI_VISIT, Botan_FFI::invoke_view_callback(), and Botan::NamedCurve.

botan_ec_point_add()

int botan_ec_point_add	(	botan_ec_point_t *	result,
		botan_ec_point_t	x,
		botan_ec_point_t	y )

Definition at line 346 of file ffi_ec.cpp.

                                                                                             {
   if(Botan::any_null_pointers(result)) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
   return BOTAN_FFI_VISIT(x_w, [=](auto& x) -> int {
      Botan::EC_AffinePoint res = x.add(safe_get(y_w));
      return ffi_new_object(result, std::make_unique<Botan::EC_AffinePoint>(std::move(res)));
   });
}

References Botan::EC_AffinePoint::add(), Botan::any_null_pointers(), BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_VISIT, Botan_FFI::ffi_new_object(), and Botan_FFI::safe_get().

botan_ec_point_destroy()

int botan_ec_point_destroy

(

botan_ec_point_t

ec_point

)

Definition at line 230 of file ffi_ec.cpp.

                                                      {
   return BOTAN_FFI_CHECKED_DELETE(ec_point);
}

References BOTAN_FFI_CHECKED_DELETE.

botan_ec_point_equal()

int botan_ec_point_equal	(	botan_ec_point_t	x,
		botan_ec_point_t	y )

Returns

1 if

Parameters

x	==
y	else 0 otherwise

Returns

negative number on error

Definition at line 319 of file ffi_ec.cpp.

                                                                     {
   return BOTAN_FFI_VISIT(x_w, [=](const auto& x) -> int { return x == safe_get(y_w) ? 1 : 0; });
}

References BOTAN_FFI_VISIT, and Botan_FFI::safe_get().

botan_ec_point_from_bytes()

int botan_ec_point_from_bytes	(	botan_ec_point_t *	ec_point,
		botan_ec_group_t	ec_group,
		const uint8_t *	bytes,
		size_t	bytes_len )

Create a point from a SEC1 compressed or uncompressed format.

Returns

negative number on error

Definition at line 267 of file ffi_ec.cpp.

                                                {
   if(Botan::any_null_pointers(ec_point, bytes)) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
   return BOTAN_FFI_VISIT(ec_group, [=](const auto& g) -> int {
      Botan::EC_AffinePoint pt(g, std::span{bytes, bytes_len});
      return ffi_new_object(ec_point, std::make_unique<Botan::EC_AffinePoint>(std::move(pt)));
   });
}

References Botan::any_null_pointers(), BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_VISIT, and Botan_FFI::ffi_new_object().

botan_ec_point_from_xy()

int botan_ec_point_from_xy	(	botan_ec_point_t *	ec_point,
		botan_ec_group_t	ec_group,
		botan_mp_t	x,
		botan_mp_t	y )

Create a point from a pair (x,y) of integers The integers must be within the field and must satisfy the curve equation

Definition at line 252 of file ffi_ec.cpp.

                                                                                                              {
   if(Botan::any_null_pointers(ec_point)) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
   return ffi_guard_thunk(__func__, [=]() -> int {
      std::optional<Botan::EC_AffinePoint> pt =
         Botan::EC_AffinePoint::from_bigint_xy(safe_get(ec_group), safe_get(x), safe_get(y));
      if(!pt.has_value()) {
         return BOTAN_FFI_ERROR_BAD_PARAMETER;
      }
 
      return ffi_new_object(ec_point, std::make_unique<Botan::EC_AffinePoint>(pt.value()));
   });
}

References Botan::any_null_pointers(), BOTAN_FFI_ERROR_BAD_PARAMETER, BOTAN_FFI_ERROR_NULL_POINTER, Botan_FFI::ffi_guard_thunk(), Botan_FFI::ffi_new_object(), Botan::EC_AffinePoint::from_bigint_xy(), and Botan_FFI::safe_get().

botan_ec_point_generator()

int botan_ec_point_generator	(	botan_ec_point_t *	ec_point,
		botan_ec_group_t	ec_group )

Create a point set to the standard group generator

Definition at line 243 of file ffi_ec.cpp.

                                                                                    {
   if(Botan::any_null_pointers(ec_point)) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
   return BOTAN_FFI_VISIT(ec_group, [=](const auto& g) -> int {
      return ffi_new_object(ec_point, std::make_unique<Botan::EC_AffinePoint>(Botan::EC_AffinePoint::generator(g)));
   });
}

References Botan::any_null_pointers(), BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_VISIT, Botan_FFI::ffi_new_object(), and Botan::EC_AffinePoint::generator().

botan_ec_point_identity()

int botan_ec_point_identity	(	botan_ec_point_t *	ec_point,
		botan_ec_group_t	ec_group )

Create a point set to the identity element of the group

Definition at line 234 of file ffi_ec.cpp.

                                                                                   {
   if(Botan::any_null_pointers(ec_point)) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
   return BOTAN_FFI_VISIT(ec_group, [=](const auto& g) -> int {
      return ffi_new_object(ec_point, std::make_unique<Botan::EC_AffinePoint>(Botan::EC_AffinePoint::identity(g)));
   });
}

References Botan::any_null_pointers(), BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_VISIT, Botan_FFI::ffi_new_object(), and Botan::EC_AffinePoint::identity().

botan_ec_point_is_identity()

int botan_ec_point_is_identity

(

botan_ec_point_t

ec_point

)

Returns

1 if

Parameters

ec_point

is the identity element, else 0

Returns

negative number on error

Definition at line 315 of file ffi_ec.cpp.

                                                          {
   return BOTAN_FFI_VISIT(ec_point, [=](const auto& p) -> int { return p.is_identity() ? 1 : 0; });
}

References BOTAN_FFI_VISIT.

botan_ec_point_mul()

int botan_ec_point_mul	(	botan_ec_point_t *	result,
		botan_ec_point_t	ec_point,
		botan_ec_scalar_t	ec_scalar,
		botan_rng_t	rng )

Definition at line 323 of file ffi_ec.cpp.

                                        {
   if(Botan::any_null_pointers(result)) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
   return BOTAN_FFI_VISIT(ec_point, [=](auto& pt) -> int {
      Botan::EC_AffinePoint res = pt.mul(safe_get(ec_scalar), safe_get(rng));
      return ffi_new_object(result, std::make_unique<Botan::EC_AffinePoint>(std::move(res)));
   });
}

References Botan::any_null_pointers(), BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_VISIT, Botan_FFI::ffi_new_object(), Botan::EC_AffinePoint::mul(), and Botan_FFI::safe_get().

botan_ec_point_negate()

int botan_ec_point_negate	(	botan_ec_point_t *	result,
		botan_ec_point_t	ec_point )

Parameters

ec_point	point to negate
result	contains the result

Definition at line 336 of file ffi_ec.cpp.

                                                                               {
   if(Botan::any_null_pointers(result)) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
   return BOTAN_FFI_VISIT(ec_point, [=](auto& pt) -> int {
      Botan::EC_AffinePoint res = pt.negate();
      return ffi_new_object(result, std::make_unique<Botan::EC_AffinePoint>(std::move(res)));
   });
}

References Botan::any_null_pointers(), BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_VISIT, Botan_FFI::ffi_new_object(), and Botan::EC_AffinePoint::negate().

botan_ec_point_view_compressed()

int botan_ec_point_view_compressed	(	botan_ec_point_t	ec_point,
		botan_view_ctx	ctx,
		botan_view_bin_fn	view )

View the fixed length SEC1 compressed encoding

Returns

negative number on error

Definition at line 308 of file ffi_ec.cpp.

                                                                                                          {
   return BOTAN_FFI_VISIT(ec_point, [=](const auto& p) -> int {
      auto bytes = p.serialize_compressed();
      return invoke_view_callback(view, ctx, bytes);
   });
}

References BOTAN_FFI_VISIT, and Botan_FFI::invoke_view_callback().

botan_ec_point_view_uncompressed()

int botan_ec_point_view_uncompressed	(	botan_ec_point_t	ec_point,
		botan_view_ctx	ctx,
		botan_view_bin_fn	view )

View the fixed length SEC1 uncompressed encoding

Returns

negative number on error

Definition at line 301 of file ffi_ec.cpp.

                                                                                                            {
   return BOTAN_FFI_VISIT(ec_point, [=](const auto& p) -> int {
      auto bytes = p.serialize_uncompressed();
      return invoke_view_callback(view, ctx, bytes);
   });
}

References BOTAN_FFI_VISIT, and Botan_FFI::invoke_view_callback().

botan_ec_point_view_x_bytes()

int botan_ec_point_view_x_bytes	(	botan_ec_point_t	ec_point,
		botan_view_ctx	ctx,
		botan_view_bin_fn	view )

View the fixed length encoding of the affine x coordinate

Returns

negative number on error

Definition at line 280 of file ffi_ec.cpp.

                                                                                                       {
   return BOTAN_FFI_VISIT(ec_point, [=](const auto& p) -> int {
      auto bytes = p.x_bytes();
      return invoke_view_callback(view, ctx, bytes);
   });
}

References BOTAN_FFI_VISIT, and Botan_FFI::invoke_view_callback().

botan_ec_point_view_xy_bytes()

int botan_ec_point_view_xy_bytes	(	botan_ec_point_t	ec_point,
		botan_view_ctx	ctx,
		botan_view_bin_fn	view )

View the fixed length encoding of the affine x and y coordinates

Returns

negative number on error

Definition at line 294 of file ffi_ec.cpp.

                                                                                                        {
   return BOTAN_FFI_VISIT(ec_point, [=](const auto& p) -> int {
      auto bytes = p.xy_bytes();
      return invoke_view_callback(view, ctx, bytes);
   });
}

References BOTAN_FFI_VISIT, and Botan_FFI::invoke_view_callback().

botan_ec_point_view_y_bytes()

int botan_ec_point_view_y_bytes	(	botan_ec_point_t	ec_point,
		botan_view_ctx	ctx,
		botan_view_bin_fn	view )

View the fixed length encoding of the affine y coordinate

Returns

negative number on error

Definition at line 287 of file ffi_ec.cpp.

                                                                                                       {
   return BOTAN_FFI_VISIT(ec_point, [=](const auto& p) -> int {
      auto bytes = p.y_bytes();
      return invoke_view_callback(view, ctx, bytes);
   });
}

References BOTAN_FFI_VISIT, and Botan_FFI::invoke_view_callback().

botan_ec_privkey_create()

int botan_ec_privkey_create	(	botan_privkey_t *	key,
		const char *	algo_name,
		botan_ec_group_t	ec_group,
		botan_rng_t	rng )

Create a new ec private key

Parameters

key	the new object will be placed here
algo_name	something like "ECDSA" or "ECDH"
EC Group	a (possibly application specific) elliptic curve
Random Number Generators	a random number generator

Definition at line 61 of file ffi_pkey.cpp.

                                                 {
   // TODO(Botan4) remove this implicit algorithm choice and reject nullptr algo_name
   if(algo_name == nullptr) {
      return botan_ec_privkey_create(key_obj, "ECDSA", ec_group_obj, rng_obj);
   }
 
   return ffi_guard_thunk(__func__, [=]() -> int {
      if(key_obj == nullptr) {
         return BOTAN_FFI_ERROR_NULL_POINTER;
      }
      *key_obj = nullptr;
 
      const Botan::EC_Group ec_group = safe_get(ec_group_obj);
      Botan::RandomNumberGenerator& rng = safe_get(rng_obj);
 
      if(auto key = Botan::create_ec_private_key(algo_name, ec_group, rng)) {
         return ffi_new_object(key_obj, std::move(key));
      } else {
         return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
      }
   });
}

References botan_ec_privkey_create(), BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, Botan::create_ec_private_key(), Botan_FFI::ffi_guard_thunk(), Botan_FFI::ffi_new_object(), and Botan_FFI::safe_get().

Referenced by botan_ec_privkey_create().

botan_ec_privkey_get_group()

int botan_ec_privkey_get_group	(	botan_privkey_t	key,
		botan_ec_group_t *	ec_group )

Definition at line 859 of file ffi_pkey_algs.cpp.

                                                                                {
   if(Botan::any_null_pointers(ec_group)) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
 
#if defined(BOTAN_HAS_ECC_KEY)
   return ffi_guard_thunk(__func__, [=]() -> int {
      const Botan::EC_PrivateKey* ec_key = dynamic_cast<const Botan::EC_PrivateKey*>(&safe_get(key));
      if(ec_key == nullptr) {
         return BOTAN_FFI_ERROR_BAD_PARAMETER;
      }
      return ffi_new_object(ec_group, std::make_unique<Botan::EC_Group>(ec_key->domain()));
   });
#else
   BOTAN_UNUSED(key, ec_group);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References Botan::any_null_pointers(), BOTAN_FFI_ERROR_BAD_PARAMETER, BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_UNUSED, Botan::EC_PublicKey::domain(), Botan_FFI::ffi_guard_thunk(), Botan_FFI::ffi_new_object(), and Botan_FFI::safe_get().

botan_ec_privkey_get_private_key()

int botan_ec_privkey_get_private_key	(	botan_privkey_t	key,
		botan_ec_scalar_t *	value )

Loads Diffie Hellman public key

Parameters

key	variable populated with key material
p	prime order of a Z_p group
g	group generator
y	public key

Precondition

key is NULL on input

Postcondition

function allocates memory and assigns to `key'

Returns

0 on success, a negative value on failure */ int botan_pubkey_load_dh(botan_pubkey_t* key, botan_mp_t p, botan_mp_t g, botan_mp_t y);

/* Algorithm specific key operations: ElGamal Loads ElGamal public key

Parameters

key	variable populated with key material
p	prime order of a Z_p group
g	group generator
y	public key

Precondition

key is NULL on input

Postcondition

function allocates memory and assigns to `key'

Returns

0 on success, a negative value on failure */ int botan_pubkey_load_elgamal(botan_pubkey_t* key, botan_mp_t p, botan_mp_t g, botan_mp_t y);

/** Loads ElGamal private key

Parameters

key	variable populated with key material
p	prime order of a Z_p group
g	group generator
x	private key

Precondition

key is NULL on input

Postcondition

function allocates memory and assigns to `key'

Returns

0 on success, a negative value on failure */ int botan_privkey_load_elgamal(botan_privkey_t* key, botan_mp_t p, botan_mp_t g, botan_mp_t x);

/* Algorithm specific key operations: EC keys

Definition at line 841 of file ffi_pkey_algs.cpp.

                                                                                    {
   if(Botan::any_null_pointers(value)) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
#if defined(BOTAN_HAS_ECC_KEY)
   return ffi_guard_thunk(__func__, [=]() -> int {
      const Botan::EC_PrivateKey* ec_key = dynamic_cast<const Botan::EC_PrivateKey*>(&safe_get(key));
      if(ec_key == nullptr) {
         return BOTAN_FFI_ERROR_BAD_PARAMETER;
      }
      return ffi_new_object(value, std::make_unique<Botan::EC_Scalar>(ec_key->_private_key()));
   });
#else
   BOTAN_UNUSED(key, value);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References Botan::EC_PrivateKey::_private_key(), Botan::any_null_pointers(), BOTAN_FFI_ERROR_BAD_PARAMETER, BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_UNUSED, Botan_FFI::ffi_guard_thunk(), Botan_FFI::ffi_new_object(), and Botan_FFI::safe_get().

botan_ec_pubkey_get_group()

int botan_ec_pubkey_get_group	(	botan_pubkey_t	key,
		botan_ec_group_t *	ec_group )

Definition at line 878 of file ffi_pkey_algs.cpp.

                                                                              {
   if(Botan::any_null_pointers(ec_group)) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
#if defined(BOTAN_HAS_ECC_KEY)
   return ffi_guard_thunk(__func__, [=]() -> int {
      const Botan::EC_PublicKey* ec_key = dynamic_cast<const Botan::EC_PublicKey*>(&safe_get(key));
      if(ec_key == nullptr) {
         return BOTAN_FFI_ERROR_BAD_PARAMETER;
      }
      return ffi_new_object(ec_group, std::make_unique<Botan::EC_Group>(ec_key->domain()));
   });
#else
   BOTAN_UNUSED(key, ec_group);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References Botan::any_null_pointers(), BOTAN_FFI_ERROR_BAD_PARAMETER, BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_UNUSED, Botan::EC_PublicKey::domain(), Botan_FFI::ffi_guard_thunk(), Botan_FFI::ffi_new_object(), and Botan_FFI::safe_get().

botan_ec_scalar_destroy()

int botan_ec_scalar_destroy

(

botan_ec_scalar_t

ec_scalar

)

Definition at line 196 of file ffi_ec.cpp.

                                                         {
   return BOTAN_FFI_CHECKED_DELETE(ec_scalar);
}

References BOTAN_FFI_CHECKED_DELETE.

botan_ec_scalar_from_mp()

int botan_ec_scalar_from_mp	(	botan_ec_scalar_t *	ec_scalar,
		botan_ec_group_t	ec_group,
		botan_mp_t	mp )

Convert from an MPI to a scalar

Returns

a negative number if the provided MPI is negative or too large, 0 on success

Definition at line 209 of file ffi_ec.cpp.

                                                                                                    {
   if(Botan::any_null_pointers(ec_scalar)) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
   return BOTAN_FFI_VISIT(ec_group, [=](const auto& g) -> int {
      return ffi_new_object(ec_scalar,
                            std::make_unique<Botan::EC_Scalar>(Botan::EC_Scalar::from_bigint(g, safe_get(mp))));
   });
}

References Botan::any_null_pointers(), BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_VISIT, Botan_FFI::ffi_new_object(), Botan::EC_Scalar::from_bigint(), and Botan_FFI::safe_get().

botan_ec_scalar_random()

int botan_ec_scalar_random	(	botan_ec_scalar_t *	ec_scalar,
		botan_ec_group_t	ec_group,
		botan_rng_t	rng )

Create a new random scalar value

Definition at line 200 of file ffi_ec.cpp.

                                                                                                     {
   if(Botan::any_null_pointers(ec_scalar)) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
   return BOTAN_FFI_VISIT(ec_group, [=](const auto& g) -> int {
      return ffi_new_object(ec_scalar, std::make_unique<Botan::EC_Scalar>(Botan::EC_Scalar::random(g, safe_get(rng))));
   });
}

References Botan::any_null_pointers(), BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_VISIT, Botan_FFI::ffi_new_object(), Botan::EC_Scalar::random(), and Botan_FFI::safe_get().

botan_ec_scalar_to_mp()

int botan_ec_scalar_to_mp	(	botan_ec_scalar_t	ec_scalar,
		botan_mp_t *	mp )

Convert from a scalar to an MPI

Returns

a negative number on failure, 0 on success

Definition at line 219 of file ffi_ec.cpp.

                                                                       {
   if(Botan::any_null_pointers(mp)) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
   return BOTAN_FFI_VISIT(ec_scalar, [=](const auto& sc) -> int {
      return ffi_new_object(mp, std::make_unique<Botan::BigInt>(sc.to_bigint()));
   });
}

References Botan::any_null_pointers(), BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_VISIT, and Botan_FFI::ffi_new_object().

botan_error_description()

const char * botan_error_description

(

int

err

)

Convert an error code into a string. Returns "Unknown error" if the error code is not a known one.

Definition at line 142 of file ffi.cpp.

                                             {
   switch(err) {
      case BOTAN_FFI_SUCCESS:
         return "OK";
 
      case BOTAN_FFI_INVALID_VERIFIER:
         return "Invalid verifier";
 
      case BOTAN_FFI_ERROR_INVALID_INPUT:
         return "Invalid input";
 
      case BOTAN_FFI_ERROR_BAD_MAC:
         return "Invalid authentication code";
 
      case BOTAN_FFI_ERROR_NO_VALUE:
         return "No value available";
 
      case BOTAN_FFI_ERROR_INSUFFICIENT_BUFFER_SPACE:
         return "Insufficient buffer space";
 
      case BOTAN_FFI_ERROR_STRING_CONVERSION_ERROR:
         return "String conversion error";
 
      case BOTAN_FFI_ERROR_EXCEPTION_THROWN:
         return "Exception thrown";
 
      case BOTAN_FFI_ERROR_OUT_OF_MEMORY:
         return "Out of memory";
 
      case BOTAN_FFI_ERROR_SYSTEM_ERROR:
         return "Error while calling system API";
 
      case BOTAN_FFI_ERROR_INTERNAL_ERROR:
         return "Internal error";
 
      case BOTAN_FFI_ERROR_BAD_FLAG:
         return "Bad flag";
 
      case BOTAN_FFI_ERROR_NULL_POINTER:
         return "Null pointer argument";
 
      case BOTAN_FFI_ERROR_BAD_PARAMETER:
         return "Bad parameter";
 
      case BOTAN_FFI_ERROR_KEY_NOT_SET:
         return "Key not set on object";
 
      case BOTAN_FFI_ERROR_INVALID_KEY_LENGTH:
         return "Invalid key length";
 
      case BOTAN_FFI_ERROR_INVALID_OBJECT_STATE:
         return "Invalid object state";
 
      case BOTAN_FFI_ERROR_OUT_OF_RANGE:
         return "Index out of range";
 
      case BOTAN_FFI_ERROR_NOT_IMPLEMENTED:
         return "Not implemented";
 
      case BOTAN_FFI_ERROR_INVALID_OBJECT:
         return "Invalid object handle";
 
      case BOTAN_FFI_ERROR_TLS_ERROR:
         return "TLS error";
 
      case BOTAN_FFI_ERROR_HTTP_ERROR:
         return "HTTP error";
 
      case BOTAN_FFI_ERROR_UNKNOWN_ERROR:
      default:
         return "Unknown error";
   }
}

References BOTAN_FFI_ERROR_BAD_FLAG, BOTAN_FFI_ERROR_BAD_MAC, BOTAN_FFI_ERROR_BAD_PARAMETER, BOTAN_FFI_ERROR_EXCEPTION_THROWN, BOTAN_FFI_ERROR_HTTP_ERROR, BOTAN_FFI_ERROR_INSUFFICIENT_BUFFER_SPACE, BOTAN_FFI_ERROR_INTERNAL_ERROR, BOTAN_FFI_ERROR_INVALID_INPUT, BOTAN_FFI_ERROR_INVALID_KEY_LENGTH, BOTAN_FFI_ERROR_INVALID_OBJECT, BOTAN_FFI_ERROR_INVALID_OBJECT_STATE, BOTAN_FFI_ERROR_KEY_NOT_SET, BOTAN_FFI_ERROR_NO_VALUE, BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_ERROR_OUT_OF_MEMORY, BOTAN_FFI_ERROR_OUT_OF_RANGE, BOTAN_FFI_ERROR_STRING_CONVERSION_ERROR, BOTAN_FFI_ERROR_SYSTEM_ERROR, BOTAN_FFI_ERROR_TLS_ERROR, BOTAN_FFI_ERROR_UNKNOWN_ERROR, BOTAN_FFI_INVALID_VERIFIER, and BOTAN_FFI_SUCCESS.

botan_error_last_exception_message()

const char * botan_error_last_exception_message

(

void

)

Return the message of the last exception caught in this thread.

This pointer can/will be reallocated or overwritten the next time this thread calls any other Botan FFI function and must be copied to persistent storage first.

Definition at line 138 of file ffi.cpp.

                                                 {
   return g_last_exception_what.c_str();
}

botan_ffi_api_version()

uint32_t botan_ffi_api_version

(

void

)

Return the version of the currently supported FFI API. This is expressed in the form YYYYMMDD of the release date of this version of the API.

Definition at line 219 of file ffi.cpp.

                                 {
   return BOTAN_HAS_FFI;
}

References BOTAN_HAS_FFI.

botan_ffi_supports_api()

int botan_ffi_supports_api

(

uint32_t

api_version

)

Return 0 (ok) if the version given is one this library supports. botan_ffi_supports_api(botan_ffi_api_version()) will always return 0.

Definition at line 223 of file ffi.cpp.

                                                 {
   // This is the API introduced in 3.12
   if(api_version == 20260506) {
      return BOTAN_FFI_SUCCESS;
   }
 
   // This is the API introduced in 3.11
   if(api_version == 20260303) {
      return BOTAN_FFI_SUCCESS;
   }
 
   // This is the API introduced in 3.10
   if(api_version == 20250829) {
      return BOTAN_FFI_SUCCESS;
   }
 
   // This is the API introduced in 3.8
   if(api_version == 20250506) {
      return BOTAN_FFI_SUCCESS;
   }
 
   // This is the API introduced in 3.4
   if(api_version == 20240408) {
      return BOTAN_FFI_SUCCESS;
   }
 
   // This is the API introduced in 3.2
   if(api_version == 20231009) {
      return BOTAN_FFI_SUCCESS;
   }
 
   // This is the API introduced in 3.1
   if(api_version == 20230711) {
      return BOTAN_FFI_SUCCESS;
   }
 
   // This is the API introduced in 3.0
   if(api_version == 20230403) {
      return BOTAN_FFI_SUCCESS;
   }
 
   // This is the API introduced in 2.18
   if(api_version == 20210220) {
      return BOTAN_FFI_SUCCESS;
   }
 
   // This is the API introduced in 2.13
   if(api_version == 20191214) {
      return BOTAN_FFI_SUCCESS;
   }
 
   // This is the API introduced in 2.8
   if(api_version == 20180713) {
      return BOTAN_FFI_SUCCESS;
   }
 
   // This is the API introduced in 2.3
   if(api_version == 20170815) {
      return BOTAN_FFI_SUCCESS;
   }
 
   // This is the API introduced in 2.1
   if(api_version == 20170327) {
      return BOTAN_FFI_SUCCESS;
   }
 
   // This is the API introduced in 2.0
   if(api_version == 20150515) {
      return BOTAN_FFI_SUCCESS;
   }
 
   // Something else:
   return -1;
}

References BOTAN_FFI_SUCCESS.

botan_fpe_decrypt()

int botan_fpe_decrypt	(	botan_fpe_t	fpe,
		botan_mp_t	x,
		const uint8_t	tweak[],
		size_t	tweak_len )

Definition at line 78 of file ffi_fpe.cpp.

                                                                                              {
#if defined(BOTAN_HAS_FPE_FE1)
   return ffi_guard_thunk(__func__, [=]() {
      const Botan::BigInt r = safe_get(fpe).decrypt(safe_get(x), tweak, tweak_len);
      safe_get(x) = r;
      return BOTAN_FFI_SUCCESS;
   });
 
#else
   BOTAN_UNUSED(fpe, x, tweak, tweak_len);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_SUCCESS, BOTAN_UNUSED, Botan_FFI::ffi_guard_thunk(), and Botan_FFI::safe_get().

botan_fpe_destroy()

int botan_fpe_destroy

(

botan_fpe_t

fpe

)

Returns

0 if success, error if invalid object handle

Definition at line 56 of file ffi_fpe.cpp.

                                       {
#if defined(BOTAN_HAS_FPE_FE1)
   return BOTAN_FFI_CHECKED_DELETE(fpe);
#else
   BOTAN_UNUSED(fpe);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References BOTAN_FFI_CHECKED_DELETE, BOTAN_FFI_ERROR_NOT_IMPLEMENTED, and BOTAN_UNUSED.

botan_fpe_encrypt()

int botan_fpe_encrypt	(	botan_fpe_t	fpe,
		botan_mp_t	x,
		const uint8_t	tweak[],
		size_t	tweak_len )

Definition at line 65 of file ffi_fpe.cpp.

                                                                                              {
#if defined(BOTAN_HAS_FPE_FE1)
   return ffi_guard_thunk(__func__, [=]() {
      const Botan::BigInt r = safe_get(fpe).encrypt(safe_get(x), tweak, tweak_len);
      safe_get(x) = r;
      return BOTAN_FFI_SUCCESS;
   });
#else
   BOTAN_UNUSED(fpe, x, tweak, tweak_len);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_SUCCESS, BOTAN_UNUSED, Botan_FFI::ffi_guard_thunk(), and Botan_FFI::safe_get().

botan_fpe_fe1_init()

int botan_fpe_fe1_init	(	botan_fpe_t *	fpe,
		botan_mp_t	n,
		const uint8_t	key[],
		size_t	key_len,
		size_t	rounds,
		uint32_t	flags )

Definition at line 28 of file ffi_fpe.cpp.

                                                                                                       {
#if defined(BOTAN_HAS_FPE_FE1)
   return ffi_guard_thunk(__func__, [=]() {
      if(fpe == nullptr || key == nullptr) {
         return BOTAN_FFI_ERROR_NULL_POINTER;
      }
 
      *fpe = nullptr;
 
      if(flags != 0 && flags != BOTAN_FPE_FLAG_FE1_COMPAT_MODE) {
         return BOTAN_FFI_ERROR_BAD_FLAG;
      }
 
      const bool compat_mode = (flags & BOTAN_FPE_FLAG_FE1_COMPAT_MODE) != 0;
 
      auto fpe_obj = std::make_unique<Botan::FPE_FE1>(safe_get(n), rounds, compat_mode);
 
      fpe_obj->set_key(key, key_len);
 
      return ffi_new_object(fpe, std::move(fpe_obj));
   });
#else
   BOTAN_UNUSED(fpe, n, key, key_len, rounds, flags);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References BOTAN_FFI_ERROR_BAD_FLAG, BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FPE_FLAG_FE1_COMPAT_MODE, BOTAN_UNUSED, Botan_FFI::ffi_guard_thunk(), Botan_FFI::ffi_new_object(), and Botan_FFI::safe_get().

botan_hash_block_size()

int botan_hash_block_size	(	botan_hash_t	hash,
		size_t *	block_size )

Writes the block size of the hash function to *block_size

Parameters

Hashes	hash object
block_size	output buffer to hold the hash function output length

Returns

0 on success, a negative value on failure

Definition at line 48 of file ffi_hash.cpp.

                                                          {
   if(out == nullptr) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
   return BOTAN_FFI_VISIT(hash, [=](const auto& h) { *out = h.hash_block_size(); });
}

References BOTAN_FFI_ERROR_NULL_POINTER, and BOTAN_FFI_VISIT.

botan_hash_clear()

int botan_hash_clear

(

botan_hash_t

hash

)

Reinitializes the state of the hash computation. A hash can be computed (with update/final) immediately.

Parameters

Hashes

hash object

Returns

0 on success, a negative value on failure

Definition at line 55 of file ffi_hash.cpp.

                                        {
   return BOTAN_FFI_VISIT(hash, [](auto& h) { h.clear(); });
}

References BOTAN_FFI_VISIT.

botan_hash_copy_state()

int botan_hash_copy_state	(	botan_hash_t *	dest,
		botan_hash_t	source )

Copy the state of a hash function object

Parameters

dest	destination hash object
source	source hash object

Returns

0 on success, a negative value on failure

Definition at line 79 of file ffi_hash.cpp.

                                                                         {
   if(dest == nullptr) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
   return BOTAN_FFI_VISIT(source, [=](const auto& src) { return ffi_new_object(dest, src.copy_state()); });
}

References BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_VISIT, and Botan_FFI::ffi_new_object().

botan_hash_destroy()

int botan_hash_destroy

(

botan_hash_t

hash

)

Frees all resources of the hash object

Parameters

Hashes

hash object

Returns

0 if success, error if invalid object handle

Definition at line 37 of file ffi_hash.cpp.

                                          {
   return BOTAN_FFI_CHECKED_DELETE(hash);
}

References BOTAN_FFI_CHECKED_DELETE.

botan_hash_final()

int botan_hash_final	(	botan_hash_t	hash,
		uint8_t	out[] )

Finalizes the hash computation and writes the output to out[0:botan_hash_output_length()] then reinitializes for computing another digest as if botan_hash_clear had been called.

Parameters

Hashes	hash object
out	output buffer

Returns

0 on success, a negative value on failure

Definition at line 71 of file ffi_hash.cpp.

                                                       {
   if(out == nullptr) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
   return BOTAN_FFI_VISIT(hash, [=](auto& h) { h.final(out); });
}

References BOTAN_FFI_ERROR_NULL_POINTER, and BOTAN_FFI_VISIT.

botan_hash_init()

int botan_hash_init	(	botan_hash_t *	hash,
		const char *	hash_name,
		uint32_t	flags )

Initialize a hash function object

Parameters

Hashes	hash object
hash_name	name of the hash function, e.g., "SHA-384"
flags	should be 0 in current API revision, all other uses are reserved and return BOTAN_FFI_ERROR_BAD_FLAG

Definition at line 18 of file ffi_hash.cpp.

                                                                               {
   return ffi_guard_thunk(__func__, [=]() -> int {
      if(hash == nullptr || hash_name == nullptr || *hash_name == 0) {
         return BOTAN_FFI_ERROR_NULL_POINTER;
      }
      if(flags != 0) {
         return BOTAN_FFI_ERROR_BAD_FLAG;
      }
 
      auto h = Botan::HashFunction::create(hash_name);
      if(h == nullptr) {
         return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
      }
 
      ffi_new_object(hash, std::move(h));
      return BOTAN_FFI_SUCCESS;
   });
}

References BOTAN_FFI_ERROR_BAD_FLAG, BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_SUCCESS, Botan::HashFunction::create(), Botan_FFI::ffi_guard_thunk(), and Botan_FFI::ffi_new_object().

botan_hash_name()

int botan_hash_name	(	botan_hash_t	hash,
		char *	name,
		size_t *	name_len )

Get the name of this hash function

Parameters

Hashes	the object to read
name	output buffer
name_len	on input, the length of buffer, on success the number of bytes written

Definition at line 86 of file ffi_hash.cpp.

                                                                     {
   if(name_len == nullptr) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
 
   return BOTAN_FFI_VISIT(hash, [=](const auto& h) { return write_str_output(name, name_len, h.name()); });
}

References BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_VISIT, and Botan_FFI::write_str_output().

botan_hash_output_length()

int botan_hash_output_length	(	botan_hash_t	hash,
		size_t *	output_length )

Writes the output length of the hash function to *output_length

Parameters

Hashes	hash object
output_length	output buffer to hold the hash function output length

Returns

0 on success, a negative value on failure

Definition at line 41 of file ffi_hash.cpp.

                                                             {
   if(out == nullptr) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
   return BOTAN_FFI_VISIT(hash, [=](const auto& h) { *out = h.output_length(); });
}

References BOTAN_FFI_ERROR_NULL_POINTER, and BOTAN_FFI_VISIT.

botan_hash_update()

int botan_hash_update	(	botan_hash_t	hash,
		const uint8_t *	in,
		size_t	in_len )

Send more input to the hash function

Parameters

Hashes	hash object
in	input buffer
in_len	number of bytes to read from the input buffer

Returns

0 on success, a negative value on failure

Definition at line 59 of file ffi_hash.cpp.

                                                                         {
   if(len == 0) {
      return 0;
   }
 
   if(buf == nullptr) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
 
   return BOTAN_FFI_VISIT(hash, [=](auto& h) { h.update(buf, len); });
}

References BOTAN_FFI_ERROR_NULL_POINTER, and BOTAN_FFI_VISIT.

botan_hex_decode()

int botan_hex_decode	(	const char *	hex_str,
		size_t	in_len,
		uint8_t *	out,
		size_t *	out_len )

Perform hex decoding

Parameters

hex_str	a string of hex chars (whitespace is ignored)
in_len	the length of hex_str
out	the output buffer should be at least strlen(hex_str)/2 bytes
out_len	the size of the output buffer on input, set to the number of bytes written

Returns

0 on success, a negative value on failure

Definition at line 350 of file ffi.cpp.

                                                                                        {
   if(any_null_pointers(hex_str, out_len)) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
   return ffi_guard_thunk(__func__, [=]() -> int {
      const std::vector<uint8_t> bin = Botan::hex_decode(hex_str, in_len);
      return Botan_FFI::write_vec_output(out, out_len, bin);
   });
}

References Botan_FFI::any_null_pointers(), BOTAN_FFI_ERROR_NULL_POINTER, Botan_FFI::ffi_guard_thunk(), Botan::hex_decode(), and Botan_FFI::write_vec_output().

botan_hex_encode()

int botan_hex_encode	(	const uint8_t *	x,
		size_t	len,
		char *	out,
		uint32_t	flags )

Perform hex encoding

Parameters

x	is some binary data
len	length of x in bytes
out	an array of at least x*2 bytes
flags	flags out be upper or lower case?

Returns

0 on success, a negative value on failure

Definition at line 339 of file ffi.cpp.

                                                                               {
   if(len > 0 && (in == nullptr || out == nullptr)) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
   return ffi_guard_thunk(__func__, [=]() -> int {
      const bool uppercase = (flags & BOTAN_FFI_HEX_LOWER_CASE) == 0;
      Botan::hex_encode(out, in, len, uppercase);
      return BOTAN_FFI_SUCCESS;
   });
}

References BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_HEX_LOWER_CASE, BOTAN_FFI_SUCCESS, Botan_FFI::ffi_guard_thunk(), and Botan::hex_encode().

botan_hotp_check()

int botan_hotp_check	(	botan_hotp_t	hotp,
		uint64_t *	next_hotp_counter,
		uint32_t	hotp_code,
		uint64_t	hotp_counter,
		size_t	resync_range )

Verify a HOTP code

Definition at line 67 of file ffi_hotp.cpp.

                                                                                                                   {
#if defined(BOTAN_HAS_HOTP)
   return BOTAN_FFI_VISIT(hotp, [=](auto& h) {
      auto resp = h.verify_hotp(hotp_code, hotp_counter, resync_range);
 
      if(next_hotp_counter) {
         *next_hotp_counter = resp.second;
      }
 
      return (resp.first == true) ? BOTAN_FFI_SUCCESS : BOTAN_FFI_INVALID_VERIFIER;
   });
 
#else
   BOTAN_UNUSED(hotp, next_hotp_counter, hotp_code, hotp_counter, resync_range);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_INVALID_VERIFIER, BOTAN_FFI_SUCCESS, BOTAN_FFI_VISIT, and BOTAN_UNUSED.

botan_hotp_destroy()

int botan_hotp_destroy

(

botan_hotp_t

hotp

)

Destroy a HOTP instance

Returns

0 if success, error if invalid object handle

Definition at line 44 of file ffi_hotp.cpp.

                                          {
#if defined(BOTAN_HAS_HOTP)
   return BOTAN_FFI_CHECKED_DELETE(hotp);
#else
   BOTAN_UNUSED(hotp);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References BOTAN_FFI_CHECKED_DELETE, BOTAN_FFI_ERROR_NOT_IMPLEMENTED, and BOTAN_UNUSED.

botan_hotp_generate()

int botan_hotp_generate	(	botan_hotp_t	hotp,
		uint32_t *	hotp_code,
		uint64_t	hotp_counter )

Generate a HOTP code for the provided counter

Definition at line 53 of file ffi_hotp.cpp.

                                                                                       {
#if defined(BOTAN_HAS_HOTP)
   if(hotp == nullptr || hotp_code == nullptr) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
 
   return BOTAN_FFI_VISIT(hotp, [=](auto& h) { *hotp_code = h.generate_hotp(hotp_counter); });
 
#else
   BOTAN_UNUSED(hotp, hotp_code, hotp_counter);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_VISIT, and BOTAN_UNUSED.

botan_hotp_init()

int botan_hotp_init	(	botan_hotp_t *	hotp,
		const uint8_t	key[],
		size_t	key_len,
		const char *	hash_algo,
		size_t	digits )

Initialize a HOTP instance

Definition at line 26 of file ffi_hotp.cpp.

                                                                                                                   {
   if(hotp == nullptr || key == nullptr || hash_algo == nullptr) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
 
   *hotp = nullptr;
 
#if defined(BOTAN_HAS_HOTP)
   return ffi_guard_thunk(__func__, [=]() -> int {
      auto otp = std::make_unique<Botan::HOTP>(key, key_len, hash_algo, digits);
      return ffi_new_object(hotp, std::move(otp));
   });
#else
   BOTAN_UNUSED(hotp, key, key_len, hash_algo, digits);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_UNUSED, Botan_FFI::ffi_guard_thunk(), and Botan_FFI::ffi_new_object().

botan_kdf()

int botan_kdf	(	const char *	kdf_algo,
		uint8_t	out[],
		size_t	out_len,
		const uint8_t	secret[],
		size_t	secret_len,
		const uint8_t	salt[],
		size_t	salt_len,
		const uint8_t	label[],
		size_t	label_len )

Derive a key

Parameters

kdf_algo	KDF algorithm, e.g., "SP800-56C"
out	buffer holding the derived key, must be of length out_len
out_len	the desired output length in bytes
secret	the secret input
secret_len	size of secret in bytes
salt	a diversifier
salt_len	size of salt in bytes
label	purpose for the derived keying material
label_len	size of label in bytes

Returns

0 on success, a negative value on failure

Definition at line 143 of file ffi_kdf.cpp.

                                {
   if(kdf_algo == nullptr) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
   if((out_len > 0 && out == nullptr) || (secret_len > 0 && secret == nullptr) || (salt_len > 0 && salt == nullptr) ||
      (label_len > 0 && label == nullptr)) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
   return ffi_guard_thunk(__func__, [=]() -> int {
      auto kdf = Botan::KDF::create_or_throw(kdf_algo);
      kdf->kdf(out, out_len, secret, secret_len, salt, salt_len, label, label_len);
      return BOTAN_FFI_SUCCESS;
   });
}

References BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_SUCCESS, Botan::KDF::create_or_throw(), and Botan_FFI::ffi_guard_thunk().

botan_key_unwrap3394()

int botan_key_unwrap3394	(	const uint8_t	wrapped_key[],
		size_t	wrapped_key_len,
		const uint8_t	kek[],
		size_t	kek_len,
		uint8_t	key[],
		size_t *	key_len )

Definition at line 104 of file ffi_keywrap.cpp.

                                          {
   const std::string cipher_name = "AES-" + std::to_string(8 * kek_len);
 
   return botan_nist_kw_dec(cipher_name.c_str(), 0, wrapped_key, wrapped_key_len, kek, kek_len, key, key_len);
}

References botan_nist_kw_dec().

botan_key_wrap3394()

int botan_key_wrap3394	(	const uint8_t	key[],
		size_t	key_len,
		const uint8_t	kek[],
		size_t	kek_len,
		uint8_t	wrapped_key[],
		size_t *	wrapped_key_len )

Key wrapping as per RFC 3394

Definition at line 93 of file ffi_keywrap.cpp.

                                                {
   const std::string cipher_name = "AES-" + std::to_string(8 * kek_len);
 
   return botan_nist_kw_enc(cipher_name.c_str(), 0, key, key_len, kek, kek_len, wrapped_key, wrapped_key_len);
}

References botan_nist_kw_enc().

botan_mac_clear()

int botan_mac_clear

(

botan_mac_t

mac

)

Reinitializes the state of the MAC computation. A MAC can be computed (with update/final) immediately.

Parameters

Message Authentication Codes

mac object

Returns

0 on success, a negative value on failure

Definition at line 58 of file ffi_mac.cpp.

                                     {
   return BOTAN_FFI_VISIT(mac, [](auto& m) { m.clear(); });
}

References BOTAN_FFI_VISIT.

botan_mac_destroy()

int botan_mac_destroy

(

botan_mac_t

mac

)

Frees all resources of the MAC object

Parameters

Message Authentication Codes

mac object

Returns

0 if success, error if invalid object handle

Definition at line 36 of file ffi_mac.cpp.

                                       {
   return BOTAN_FFI_CHECKED_DELETE(mac);
}

References BOTAN_FFI_CHECKED_DELETE.

botan_mac_final()

int botan_mac_final	(	botan_mac_t	mac,
		uint8_t	out[] )

Finalizes the MAC computation and writes the output to out[0:botan_mac_output_length()] then reinitializes for computing another MAC as if botan_mac_clear had been called.

Parameters

Message Authentication Codes	mac object
out	output buffer

Returns

0 on success, a negative value on failure

Definition at line 72 of file ffi_mac.cpp.

                                                    {
   if(out == nullptr) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
   return BOTAN_FFI_VISIT(mac, [=](auto& m) { m.final(out); });
}

References BOTAN_FFI_ERROR_NULL_POINTER, and BOTAN_FFI_VISIT.

botan_mac_get_keyspec()

int botan_mac_get_keyspec	(	botan_mac_t	mac,
		size_t *	out_minimum_keylength,
		size_t *	out_maximum_keylength,
		size_t *	out_keylength_modulo )

Get the key length limits of this auth code

Parameters

Message Authentication Codes	the object to read
out_minimum_keylength	if non-NULL, will be set to minimum keylength of MAC
out_maximum_keylength	if non-NULL, will be set to maximum keylength of MAC
out_keylength_modulo	if non-NULL will be set to byte multiple of valid keys

Definition at line 83 of file ffi_mac.cpp.

                                                        {
   return BOTAN_FFI_VISIT(mac, [=](auto& m) {
      if(out_minimum_keylength) {
         *out_minimum_keylength = m.minimum_keylength();
      }
      if(out_maximum_keylength) {
         *out_maximum_keylength = m.maximum_keylength();
      }
      if(out_keylength_modulo) {
         *out_keylength_modulo = m.key_spec().keylength_multiple();
      }
   });
}

References BOTAN_FFI_VISIT.

botan_mac_init()

int botan_mac_init	(	botan_mac_t *	mac,
		const char *	mac_name,
		uint32_t	flags )

Initialize a message authentication code object

Parameters

Message Authentication Codes	mac object
mac_name	name of the hash function, e.g., "HMAC(SHA-384)"
flags	should be 0 in current API revision, all other uses are reserved and return a negative value (error code)

Returns

0 on success, a negative value on failure

Definition at line 18 of file ffi_mac.cpp.

                                                                           {
   return ffi_guard_thunk(__func__, [=]() -> int {
      if(any_null_pointers(mac, mac_name)) {
         return BOTAN_FFI_ERROR_NULL_POINTER;
      }
 
      if(flags != 0) {
         return BOTAN_FFI_ERROR_BAD_FLAG;
      }
 
      if(auto m = Botan::MessageAuthenticationCode::create(mac_name)) {
         return ffi_new_object(mac, std::move(m));
      } else {
         return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
      }
   });
}

References Botan_FFI::any_null_pointers(), BOTAN_FFI_ERROR_BAD_FLAG, BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, Botan::MessageAuthenticationCode::create(), Botan_FFI::ffi_guard_thunk(), and Botan_FFI::ffi_new_object().

botan_mac_name()

int botan_mac_name	(	botan_mac_t	mac,
		char *	name,
		size_t *	name_len )

Get the name of this MAC

Parameters

Message Authentication Codes	the object to read
name	output buffer
name_len	on input, the length of buffer, on success the number of bytes written

Definition at line 79 of file ffi_mac.cpp.

                                                                  {
   return BOTAN_FFI_VISIT(mac, [=](const auto& m) { return write_str_output(name, name_len, m.name()); });
}

References BOTAN_FFI_VISIT, and Botan_FFI::write_str_output().

botan_mac_output_length()

int botan_mac_output_length	(	botan_mac_t	mac,
		size_t *	output_length )

Writes the output length of the message authentication code to *output_length

Parameters

Message Authentication Codes	mac object
output_length	output buffer to hold the MAC output length

Returns

0 on success, a negative value on failure

Definition at line 51 of file ffi_mac.cpp.

                                                          {
   if(out == nullptr) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
   return BOTAN_FFI_VISIT(mac, [=](const auto& m) { *out = m.output_length(); });
}

References BOTAN_FFI_ERROR_NULL_POINTER, and BOTAN_FFI_VISIT.

botan_mac_set_key()

int botan_mac_set_key	(	botan_mac_t	mac,
		const uint8_t *	key,
		size_t	key_len )

Sets the key on the MAC

Parameters

Message Authentication Codes	mac object
key	buffer holding the key
key_len	size of the key buffer in bytes

Returns

0 on success, a negative value on failure

Definition at line 40 of file ffi_mac.cpp.

                                                                           {
   if(key_len > 0 && key == nullptr) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
   return BOTAN_FFI_VISIT(mac, [=](auto& m) { m.set_key(key, key_len); });
}

References BOTAN_FFI_ERROR_NULL_POINTER, and BOTAN_FFI_VISIT.

botan_mac_set_nonce()

int botan_mac_set_nonce	(	botan_mac_t	mac,
		const uint8_t *	nonce,
		size_t	nonce_len )

Sets the nonce on the MAC

Parameters

Message Authentication Codes	mac object
nonce	buffer holding the key
nonce_len	size of the key buffer in bytes

Returns

0 on success, a negative value on failure

Definition at line 47 of file ffi_mac.cpp.

                                                                                 {
   return BOTAN_FFI_VISIT(mac, [=](auto& m) { m.start(nonce, nonce_len); });
}

References BOTAN_FFI_VISIT.

botan_mac_update()

int botan_mac_update	(	botan_mac_t	mac,
		const uint8_t *	buf,
		size_t	len )

Send more input to the message authentication code

Parameters

Message Authentication Codes	mac object
buf	input buffer
len	number of bytes to read from the input buffer

Returns

0 on success, a negative value on failure

Definition at line 62 of file ffi_mac.cpp.

                                                                      {
   if(len == 0) {
      return BOTAN_FFI_SUCCESS;
   }
   if(buf == nullptr) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
   return BOTAN_FFI_VISIT(mac, [=](auto& m) { m.update(buf, len); });
}

References BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_SUCCESS, and BOTAN_FFI_VISIT.

botan_mceies_decrypt()

int botan_mceies_decrypt	(	botan_privkey_t	mce_key,
		const char *	aead,
		const uint8_t	ct[],
		size_t	ct_len,
		const uint8_t	ad[],
		size_t	ad_len,
		uint8_t	pt[],
		size_t *	pt_len )

Definition at line 1564 of file ffi_pkey_algs.cpp.

                                          {
   BOTAN_UNUSED(mce_key_obj, aead, ct, ct_len, ad, ad_len, out, out_len);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
}

References BOTAN_FFI_ERROR_NOT_IMPLEMENTED, and BOTAN_UNUSED.

botan_mceies_encrypt()

int botan_mceies_encrypt	(	botan_pubkey_t	mce_key,
		botan_rng_t	rng,
		const char *	aead,
		const uint8_t	pt[],
		size_t	pt_len,
		const uint8_t	ad[],
		size_t	ad_len,
		uint8_t	ct[],
		size_t *	ct_len )

Definition at line 1576 of file ffi_pkey_algs.cpp.

                                          {
   BOTAN_UNUSED(mce_key_obj, rng_obj, aead, pt, pt_len, ad, ad_len, out, out_len);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
}

References BOTAN_FFI_ERROR_NOT_IMPLEMENTED, and BOTAN_UNUSED.

botan_mp_add()

int botan_mp_add	(	botan_mp_t	result,
		botan_mp_t	x,
		botan_mp_t	y )

Definition at line 153 of file ffi_mp.cpp.

                                                                            {
   return BOTAN_FFI_VISIT(result, [=](auto& res) {
      if(result == x) {
         res += safe_get(y);
      } else {
         res = safe_get(x) + safe_get(y);
      }
   });
}

References BOTAN_FFI_VISIT, and Botan_FFI::safe_get().

botan_mp_add_u32()

int botan_mp_add_u32	(	botan_mp_t	result,
		botan_mp_t	x,
		uint32_t	y )

Definition at line 173 of file ffi_mp.cpp.

                                                                        {
   return BOTAN_FFI_VISIT(result, [=](auto& res) {
      if(result == x) {
         res += static_cast<Botan::word>(y);
      } else {
         res = safe_get(x) + static_cast<Botan::word>(y);
      }
   });
}

References BOTAN_FFI_VISIT, and Botan_FFI::safe_get().

botan_mp_clear()

int botan_mp_clear

(

botan_mp_t

mp

)

Set the MPI to zero

Definition at line 35 of file ffi_mp.cpp.

                                  {
   return BOTAN_FFI_VISIT(mp, [](auto& bn) { bn.clear(); });
}

References BOTAN_FFI_VISIT.

botan_mp_clear_bit()

int botan_mp_clear_bit	(	botan_mp_t	n,
		size_t	bit )

Clear the specified bit

Definition at line 290 of file ffi_mp.cpp.

                                                  {
   return BOTAN_FFI_VISIT(mp, [=](auto& n) { n.clear_bit(bit); });
}

References BOTAN_FFI_VISIT.

botan_mp_cmp()

int botan_mp_cmp	(	int *	result,
		botan_mp_t	x,
		botan_mp_t	y )

Definition at line 227 of file ffi_mp.cpp.

                                                                          {
   if(result == nullptr) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
   return BOTAN_FFI_VISIT(x_w, [=](auto& x) { *result = x.cmp(safe_get(y_w)); });
}

References BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_VISIT, and Botan_FFI::safe_get().

botan_mp_destroy()

int botan_mp_destroy

(

botan_mp_t

mp

)

Destroy (deallocate) an MPI

Returns

0 if success, error if invalid object handle

Definition at line 149 of file ffi_mp.cpp.

                                    {
   return BOTAN_FFI_CHECKED_DELETE(mp);
}

References BOTAN_FFI_CHECKED_DELETE.

botan_mp_div()

int botan_mp_div	(	botan_mp_t	quotient,
		botan_mp_t	remainder,
		botan_mp_t	x,
		botan_mp_t	y )

Definition at line 203 of file ffi_mp.cpp.

                                                                                                    {
   return BOTAN_FFI_VISIT(quotient, [=](auto& q) {
      Botan::BigInt r;
      Botan::vartime_divide(safe_get(x), safe_get(y), q, r);
      safe_get(remainder) = r;
   });
}

References BOTAN_FFI_VISIT, Botan_FFI::safe_get(), and Botan::vartime_divide().

botan_mp_equal()

int botan_mp_equal	(	botan_mp_t	x,
		botan_mp_t	y )

Definition at line 211 of file ffi_mp.cpp.

                                                               {
   return BOTAN_FFI_VISIT(x_w, [=](const auto& x) -> int { return x == safe_get(y_w); });
}

References BOTAN_FFI_VISIT, and Botan_FFI::safe_get().

botan_mp_flip_sign()

int botan_mp_flip_sign

(

botan_mp_t

mp

)

Definition at line 72 of file ffi_mp.cpp.

                                      {
   return BOTAN_FFI_VISIT(mp, [](auto& bn) { bn.flip_sign(); });
}

References BOTAN_FFI_VISIT.

botan_mp_from_bin()

int botan_mp_from_bin	(	botan_mp_t	mp,
		const uint8_t	vec[],
		size_t	vec_len )

Definition at line 76 of file ffi_mp.cpp.

                                                                          {
   if(bin_len > 0 && bin == nullptr) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
   return BOTAN_FFI_VISIT(mp, [=](auto& bn) { bn._assign_from_bytes({bin, bin_len}); });
}

References BOTAN_FFI_ERROR_NULL_POINTER, and BOTAN_FFI_VISIT.

botan_mp_gcd()

int botan_mp_gcd	(	botan_mp_t	out,
		botan_mp_t	x,
		botan_mp_t	y )

Definition at line 274 of file ffi_mp.cpp.

                                                                         {
   return BOTAN_FFI_VISIT(out, [=](auto& o) { o = Botan::gcd(safe_get(x), safe_get(y)); });
}

References BOTAN_FFI_VISIT, Botan::gcd(), and Botan_FFI::safe_get().

botan_mp_get_bit()

int botan_mp_get_bit	(	botan_mp_t	n,
		size_t	bit )

Returns 0 if specified bit of n is not set Returns 1 if specified bit of n is set Returns negative number on error

Definition at line 282 of file ffi_mp.cpp.

                                                      {
   return BOTAN_FFI_VISIT(mp, [=](const auto& n) -> int { return n.get_bit(bit); });
}

References BOTAN_FFI_VISIT.

botan_mp_init()

int botan_mp_init

(

botan_mp_t *

mp

)

Initialize an MPI

Definition at line 24 of file ffi_mp.cpp.

                                      {
   return ffi_guard_thunk(__func__, [=]() -> int {
      if(mp_out == nullptr) {
         return BOTAN_FFI_ERROR_NULL_POINTER;
      }
 
      auto mp = std::make_unique<Botan::BigInt>();
      return ffi_new_object(mp_out, std::move(mp));
   });
}

References BOTAN_FFI_ERROR_NULL_POINTER, Botan_FFI::ffi_guard_thunk(), and Botan_FFI::ffi_new_object().

botan_mp_is_even()

int botan_mp_is_even

(

botan_mp_t

mp

)

Definition at line 223 of file ffi_mp.cpp.

                                          {
   return BOTAN_FFI_VISIT(mp, [](const auto& bn) -> int { return bn.is_even(); });
}

References BOTAN_FFI_VISIT.

botan_mp_is_negative()

int botan_mp_is_negative

(

botan_mp_t

mp

)

Return 1 iff mp is less than 0

Definition at line 64 of file ffi_mp.cpp.

                                              {
   return BOTAN_FFI_VISIT(mp, [](const auto& bn) { return bn.signum() < 0 ? 1 : 0; });
}

References BOTAN_FFI_VISIT.

botan_mp_is_odd()

int botan_mp_is_odd

(

botan_mp_t

mp

)

Definition at line 219 of file ffi_mp.cpp.

                                         {
   return BOTAN_FFI_VISIT(mp, [](const auto& bn) -> int { return bn.is_odd(); });
}

References BOTAN_FFI_VISIT.

botan_mp_is_positive()

int botan_mp_is_positive

(

botan_mp_t

mp

)

This function should have been named mp_is_non_negative. Returns 1 iff mp is greater than or equal to zero. Use botan_mp_is_negative to detect negative numbers, botan_mp_is_zero to check for zero.

Definition at line 68 of file ffi_mp.cpp.

                                              {
   return BOTAN_FFI_VISIT(mp, [](const auto& bn) { return bn.signum() >= 0 ? 1 : 0; });
}

References BOTAN_FFI_VISIT.

botan_mp_is_prime()

int botan_mp_is_prime	(	botan_mp_t	n,
		botan_rng_t	rng,
		size_t	test_prob )

Returns 0 if n is not prime Returns 1 if n is prime Returns negative number on error

Definition at line 278 of file ffi_mp.cpp.

                                                                              {
   return BOTAN_FFI_VISIT(mp, [=](const auto& n) { return (Botan::is_prime(n, safe_get(rng), test_prob)) ? 1 : 0; });
}

References BOTAN_FFI_VISIT, Botan::is_prime(), and Botan_FFI::safe_get().

botan_mp_is_zero()

int botan_mp_is_zero

(

botan_mp_t

mp

)

Definition at line 215 of file ffi_mp.cpp.

                                          {
   return BOTAN_FFI_VISIT(mp, [](const auto& bn) -> int { return bn.is_zero(); });
}

References BOTAN_FFI_VISIT.

botan_mp_lshift()

int botan_mp_lshift	(	botan_mp_t	out,
		botan_mp_t	in,
		size_t	shift )

Definition at line 244 of file ffi_mp.cpp.

                                                                       {
   return BOTAN_FFI_VISIT(out, [=](auto& o) { o = safe_get(in) << shift; });
}

References BOTAN_FFI_VISIT, and Botan_FFI::safe_get().

botan_mp_mod_inverse()

int botan_mp_mod_inverse	(	botan_mp_t	out,
		botan_mp_t	in,
		botan_mp_t	modulus )

Definition at line 252 of file ffi_mp.cpp.

                                                                                        {
   return BOTAN_FFI_VISIT(out, [=](auto& o) {
      o = Botan::inverse_mod_general(safe_get(in), safe_get(modulus)).value_or(Botan::BigInt::zero());
   });
}

References BOTAN_FFI_VISIT, Botan::inverse_mod_general(), Botan_FFI::safe_get(), and Botan::BigInt::zero().

botan_mp_mod_mul()

int botan_mp_mod_mul	(	botan_mp_t	result,
		botan_mp_t	x,
		botan_mp_t	y,
		botan_mp_t	mod )

Definition at line 258 of file ffi_mp.cpp.

                                                                                                       {
   return BOTAN_FFI_VISIT(out, [=](auto& o) {
      auto reducer = Botan::Barrett_Reduction::for_secret_modulus(safe_get(modulus));
      o = reducer.multiply(safe_get(x), safe_get(y));
   });
}

References BOTAN_FFI_VISIT, Botan::Barrett_Reduction::for_secret_modulus(), and Botan_FFI::safe_get().

botan_mp_mul()

int botan_mp_mul	(	botan_mp_t	result,
		botan_mp_t	x,
		botan_mp_t	y )

Definition at line 193 of file ffi_mp.cpp.

                                                                            {
   return BOTAN_FFI_VISIT(result, [=](auto& res) {
      if(result == x) {
         res *= safe_get(y);
      } else {
         res = safe_get(x) * safe_get(y);
      }
   });
}

References BOTAN_FFI_VISIT, and Botan_FFI::safe_get().

botan_mp_num_bits()

int botan_mp_num_bits	(	botan_mp_t	n,
		size_t *	bits )

Return the number of significant bits in the MPI

Definition at line 294 of file ffi_mp.cpp.

                                                         {
   if(bits == nullptr) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
   return BOTAN_FFI_VISIT(mp, [=](const auto& n) { *bits = n.bits(); });
}

References BOTAN_FFI_ERROR_NULL_POINTER, and BOTAN_FFI_VISIT.

botan_mp_num_bytes()

int botan_mp_num_bytes	(	botan_mp_t	n,
		size_t *	bytes )

Return the number of significant bytes in the MPI

Definition at line 301 of file ffi_mp.cpp.

                                                           {
   if(bytes == nullptr) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
   return BOTAN_FFI_VISIT(mp, [=](const auto& n) { *bytes = n.bytes(); });
}

References BOTAN_FFI_ERROR_NULL_POINTER, and BOTAN_FFI_VISIT.

botan_mp_powmod()

int botan_mp_powmod	(	botan_mp_t	out,
		botan_mp_t	base,
		botan_mp_t	exponent,
		botan_mp_t	modulus )

Definition at line 239 of file ffi_mp.cpp.

                                                                                                                {
   return BOTAN_FFI_VISIT(
      out, [=](auto& o) { o = Botan::power_mod(safe_get(base), safe_get(exponent), safe_get(modulus)); });
}

References BOTAN_FFI_VISIT, Botan::power_mod(), and Botan_FFI::safe_get().

botan_mp_rand_bits()

int botan_mp_rand_bits	(	botan_mp_t	rand_out,
		botan_rng_t	rng,
		size_t	bits )

Definition at line 265 of file ffi_mp.cpp.

                                                                          {
   return BOTAN_FFI_VISIT(rng, [=](auto& r) { safe_get(rand_out).randomize(r, bits); });
}

References BOTAN_FFI_VISIT, and Botan_FFI::safe_get().

botan_mp_rand_range()

int botan_mp_rand_range	(	botan_mp_t	rand_out,
		botan_rng_t	rng,
		botan_mp_t	lower_bound,
		botan_mp_t	upper_bound )

Definition at line 269 of file ffi_mp.cpp.

                                                                                                              {
   return BOTAN_FFI_VISIT(
      rng, [=](auto& r) { safe_get(rand_out) = Botan::BigInt::random_integer(r, safe_get(lower), safe_get(upper)); });
}

References BOTAN_FFI_VISIT, Botan::BigInt::random_integer(), and Botan_FFI::safe_get().

botan_mp_rshift()

int botan_mp_rshift	(	botan_mp_t	out,
		botan_mp_t	in,
		size_t	shift )

Definition at line 248 of file ffi_mp.cpp.

                                                                       {
   return BOTAN_FFI_VISIT(out, [=](auto& o) { o = safe_get(in) >> shift; });
}

References BOTAN_FFI_VISIT, and Botan_FFI::safe_get().

botan_mp_set_bit()

int botan_mp_set_bit	(	botan_mp_t	n,
		size_t	bit )

Set the specified bit

Definition at line 286 of file ffi_mp.cpp.

                                                {
   return BOTAN_FFI_VISIT(mp, [=](auto& n) { n.set_bit(bit); });
}

References BOTAN_FFI_VISIT.

botan_mp_set_from_int()

int botan_mp_set_from_int	(	botan_mp_t	mp,
		int	initial_value )

Set the MPI value from an int

Definition at line 39 of file ffi_mp.cpp.

                                                            {
   return BOTAN_FFI_VISIT(mp, [=](auto& bn) { bn = Botan::BigInt::from_s32(initial_value); });
}

References BOTAN_FFI_VISIT, and Botan::BigInt::from_s32().

botan_mp_set_from_mp()

int botan_mp_set_from_mp	(	botan_mp_t	dest,
		botan_mp_t	source )

Set the MPI value from another MP object

Definition at line 60 of file ffi_mp.cpp.

                                                                   {
   return BOTAN_FFI_VISIT(dest, [=](auto& bn) { bn = safe_get(source); });
}

References BOTAN_FFI_VISIT, and Botan_FFI::safe_get().

botan_mp_set_from_radix_str()

int botan_mp_set_from_radix_str	(	botan_mp_t	dest,
		const char *	str,
		size_t	radix )

Set the MPI value from a string with arbitrary radix. For arbitrary being 10 or 16.

Definition at line 47 of file ffi_mp.cpp.

                                                                              {
   return BOTAN_FFI_VISIT(mp, [=](auto& bn) {
      if(radix != 10 && radix != 16) {
         return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
      }
 
      bn = Botan::BigInt::from_radix_digits(std::string_view(str), radix);
      return BOTAN_FFI_SUCCESS;
   });
}

References BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_SUCCESS, BOTAN_FFI_VISIT, and Botan::BigInt::from_radix_digits().

botan_mp_set_from_str()

int botan_mp_set_from_str	(	botan_mp_t	dest,
		const char *	str )

Set the MPI value from a string

Definition at line 43 of file ffi_mp.cpp.

                                                          {
   return BOTAN_FFI_VISIT(mp, [=](auto& bn) { bn = Botan::BigInt(str); });
}

References BOTAN_FFI_VISIT.

botan_mp_sub()

int botan_mp_sub	(	botan_mp_t	result,
		botan_mp_t	x,
		botan_mp_t	y )

Definition at line 163 of file ffi_mp.cpp.

                                                                            {
   return BOTAN_FFI_VISIT(result, [=](auto& res) {
      if(result == x) {
         res -= safe_get(y);
      } else {
         res = safe_get(x) - safe_get(y);
      }
   });
}

References BOTAN_FFI_VISIT, and Botan_FFI::safe_get().

botan_mp_sub_u32()

int botan_mp_sub_u32	(	botan_mp_t	result,
		botan_mp_t	x,
		uint32_t	y )

Definition at line 183 of file ffi_mp.cpp.

                                                                        {
   return BOTAN_FFI_VISIT(result, [=](auto& res) {
      if(result == x) {
         res -= static_cast<Botan::word>(y);
      } else {
         res = safe_get(x) - static_cast<Botan::word>(y);
      }
   });
}

References BOTAN_FFI_VISIT, and Botan_FFI::safe_get().

botan_mp_swap()

int botan_mp_swap	(	botan_mp_t	x,
		botan_mp_t	y )

Definition at line 234 of file ffi_mp.cpp.

                                                  {
   return BOTAN_FFI_VISIT(x_w, [=](auto& x) { x.swap(safe_get(y_w)); });
}

References BOTAN_FFI_VISIT, and Botan_FFI::safe_get().

botan_mp_to_bin()

int botan_mp_to_bin	(	botan_mp_t	mp,
		uint8_t	vec[] )

Definition at line 128 of file ffi_mp.cpp.

                                                        {
   if(vec == nullptr) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
   return BOTAN_FFI_VISIT(mp, [=](const auto& bn) { bn.serialize_to(std::span{vec, bn.bytes()}); });
}

References BOTAN_FFI_ERROR_NULL_POINTER, and BOTAN_FFI_VISIT.

botan_mp_to_hex()

int botan_mp_to_hex	(	botan_mp_t	mp,
		char *	out )

Convert the MPI to a hex string. Writes up to botan_mp_num_bytes(mp)*2 + 5 bytes

Prefer botan_mp_view_hex

Definition at line 83 of file ffi_mp.cpp.

                                                    {
   if(out == nullptr) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
   return BOTAN_FFI_VISIT(mp, [=](const auto& bn) {
      const std::string hex = bn.to_hex_string();
 
      // Check that we are about to write no more than the documented upper bound
      const size_t upper_bound = 2 * bn.bytes() + 5;
      BOTAN_ASSERT_NOMSG(hex.size() + 1 <= upper_bound);
      std::memcpy(out, hex.c_str(), 1 + hex.size());
   });
}

References BOTAN_ASSERT_NOMSG, BOTAN_FFI_ERROR_NULL_POINTER, and BOTAN_FFI_VISIT.

botan_mp_to_str()

int botan_mp_to_str	(	botan_mp_t	mp,
		uint8_t	radix,
		char *	out,
		size_t *	out_len )

Convert the MPI to a string. Currently radix == 10 and radix == 16 are supported.

Definition at line 104 of file ffi_mp.cpp.

                                                                                    {
   return BOTAN_FFI_VISIT(mp, [=](const auto& bn) -> int {
      if(radix == 0 || radix == 10) {
         return write_str_output(out, out_len, bn.to_dec_string());
      } else if(radix == 16) {
         return write_str_output(out, out_len, bn.to_hex_string());
      } else {
         return BOTAN_FFI_ERROR_BAD_PARAMETER;
      }
   });
}

References BOTAN_FFI_ERROR_BAD_PARAMETER, BOTAN_FFI_VISIT, and Botan_FFI::write_str_output().

botan_mp_to_uint32()

int botan_mp_to_uint32	(	botan_mp_t	mp,
		uint32_t *	val )

Definition at line 142 of file ffi_mp.cpp.

                                                           {
   if(val == nullptr) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
   return BOTAN_FFI_VISIT(mp, [=](const auto& bn) { *val = bn.to_u32bit(); });
}

References BOTAN_FFI_ERROR_NULL_POINTER, and BOTAN_FFI_VISIT.

botan_mp_view_bin()

int botan_mp_view_bin	(	botan_mp_t	mp,
		botan_view_ctx	ctx,
		botan_view_bin_fn	view )

Definition at line 135 of file ffi_mp.cpp.

                                                                                       {
   return BOTAN_FFI_VISIT(mp, [=](const auto& bn) {
      const auto bytes = bn.serialize();
      return invoke_view_callback(view, ctx, bytes);
   });
}

References BOTAN_FFI_VISIT, and Botan_FFI::invoke_view_callback().

botan_mp_view_hex()

int botan_mp_view_hex	(	botan_mp_t	mp,
		botan_view_ctx	ctx,
		botan_view_str_fn	view )

View the hex string encoding of the MPI.

Definition at line 97 of file ffi_mp.cpp.

                                                                                       {
   return BOTAN_FFI_VISIT(mp, [=](const auto& bn) -> int {
      const std::string hex = bn.to_hex_string();
      return invoke_view_callback(view, ctx, hex);
   });
}

References BOTAN_FFI_VISIT, and Botan_FFI::invoke_view_callback().

botan_mp_view_str()

int botan_mp_view_str	(	botan_mp_t	mp,
		uint8_t	radix,
		botan_view_ctx	ctx,
		botan_view_str_fn	view )

View the MPI as a radix-N integer. Currently only radix 10 and radix 16 are supported

Definition at line 116 of file ffi_mp.cpp.

                                                                                                      {
   return BOTAN_FFI_VISIT(mp, [=](const auto& bn) -> int {
      if(radix == 10) {
         return invoke_view_callback(view, ctx, bn.to_dec_string());
      } else if(radix == 16) {
         return invoke_view_callback(view, ctx, bn.to_hex_string());
      } else {
         return BOTAN_FFI_ERROR_BAD_PARAMETER;
      }
   });
}

References BOTAN_FFI_ERROR_BAD_PARAMETER, BOTAN_FFI_VISIT, and Botan_FFI::invoke_view_callback().

botan_nist_kw_dec()

int botan_nist_kw_dec	(	const char *	cipher_algo,
		int	padded,
		const uint8_t	wrapped_key[],
		size_t	wrapped_key_len,
		const uint8_t	kek[],
		size_t	kek_len,
		uint8_t	key[],
		size_t *	key_len )

Definition at line 57 of file ffi_keywrap.cpp.

                                       {
   if(any_null_pointers(cipher_algo, wrapped_key, kek)) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
#if defined(BOTAN_HAS_NIST_KEYWRAP)
   return ffi_guard_thunk(__func__, [=]() -> int {
      if(padded != 0 && padded != 1) {
         return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
      }
 
      auto bc = Botan::BlockCipher::create_or_throw(cipher_algo);
      bc->set_key(kek, kek_len);
 
      Botan::secure_vector<uint8_t> output;
 
      if(padded == 0) {
         output = Botan::nist_key_unwrap(wrapped_key, wrapped_key_len, *bc);
      } else {
         output = Botan::nist_key_unwrap_padded(wrapped_key, wrapped_key_len, *bc);
      }
 
      return write_vec_output(key, key_len, output);
   });
#else
   BOTAN_UNUSED(cipher_algo, padded, key, key_len, kek, kek_len, wrapped_key, wrapped_key_len);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References Botan_FFI::any_null_pointers(), BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_UNUSED, Botan::BlockCipher::create_or_throw(), Botan_FFI::ffi_guard_thunk(), Botan::nist_key_unwrap(), Botan::nist_key_unwrap_padded(), and Botan_FFI::write_vec_output().

Referenced by botan_key_unwrap3394().

botan_nist_kw_enc()

int botan_nist_kw_enc	(	const char *	cipher_algo,
		int	padded,
		const uint8_t	key[],
		size_t	key_len,
		const uint8_t	kek[],
		size_t	kek_len,
		uint8_t	wrapped_key[],
		size_t *	wrapped_key_len )

Definition at line 22 of file ffi_keywrap.cpp.

                                               {
   if(any_null_pointers(cipher_algo, key, kek)) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
#if defined(BOTAN_HAS_NIST_KEYWRAP)
   return ffi_guard_thunk(__func__, [=]() -> int {
      if(padded != 0 && padded != 1) {
         return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
      }
      auto bc = Botan::BlockCipher::create_or_throw(cipher_algo);
      bc->set_key(kek, kek_len);
 
      std::vector<uint8_t> output;
 
      if(padded == 0) {
         output = Botan::nist_key_wrap(key, key_len, *bc);
      } else {
         output = Botan::nist_key_wrap_padded(key, key_len, *bc);
      }
 
      return write_vec_output(wrapped_key, wrapped_key_len, output);
   });
#else
   BOTAN_UNUSED(cipher_algo, padded, key, key_len, kek, kek_len, wrapped_key, wrapped_key_len);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References Botan_FFI::any_null_pointers(), BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_UNUSED, Botan::BlockCipher::create_or_throw(), Botan_FFI::ffi_guard_thunk(), Botan::nist_key_wrap(), Botan::nist_key_wrap_padded(), and Botan_FFI::write_vec_output().

Referenced by botan_key_wrap3394().

botan_oid_cmp()

int botan_oid_cmp	(	int *	result,
		botan_asn1_oid_t	a,
		botan_asn1_oid_t	b )

Sets

Parameters

result

to comparison result: -1 if a < b, 0 if a == b, 1 if a > b

Returns

negative number on error or zero on success

Definition at line 63 of file ffi_oid.cpp.

                                                                           {
   return BOTAN_FFI_VISIT(a_w, [=](auto& a) {
      if(result == nullptr) {
         return BOTAN_FFI_ERROR_NULL_POINTER;
      }
      const Botan::OID b = safe_get(b_w);
      // we don't have .cmp for OID
      if(a == b) {
         *result = 0;
      } else if(a < b) {
         *result = -1;
      } else {
         *result = 1;
      }
      return BOTAN_FFI_SUCCESS;
   });
}

References BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_SUCCESS, BOTAN_FFI_VISIT, and Botan_FFI::safe_get().

botan_oid_destroy()

int botan_oid_destroy

(

botan_asn1_oid_t

oid

)

Returns

negative number on error, or zero on success

Definition at line 18 of file ffi_oid.cpp.

                                            {
   return BOTAN_FFI_CHECKED_DELETE(oid);
}

References BOTAN_FFI_CHECKED_DELETE.

botan_oid_equal()

int botan_oid_equal	(	botan_asn1_oid_t	a,
		botan_asn1_oid_t	b )

Returns

0 if a != b

1 if a == b

negative number on error

Definition at line 59 of file ffi_oid.cpp.

                                                                {
   return BOTAN_FFI_VISIT(a_w, [=](const auto& a) -> int { return a == safe_get(b_w); });
}

References BOTAN_FFI_VISIT, and Botan_FFI::safe_get().

botan_oid_from_string()

int botan_oid_from_string	(	botan_asn1_oid_t *	oid,
		const char *	oid_str )

Create an OID from a string, either dot notation (e.g. '1.2.3.4') or a registered name (e.g. 'RSA')

Parameters

oid	handle to the resulting OID
oid_str	the name of the OID to create

Returns

negative number on error, or zero on success

Definition at line 22 of file ffi_oid.cpp.

                                                                          {
   return ffi_guard_thunk(__func__, [=]() -> int {
      if(oid_obj == nullptr || oid_str == nullptr) {
         return BOTAN_FFI_ERROR_NULL_POINTER;
      }
      Botan::OID oid;
      // This returns a Lookup_Error if an unknown name is passed,
      // which would get turned into NOT_IMPLEMENTED
      try {
         oid = Botan::OID::from_string(oid_str);
      } catch(Botan::Lookup_Error&) {
         return BOTAN_FFI_ERROR_BAD_PARAMETER;
      }
      auto oid_ptr = std::make_unique<Botan::OID>(std::move(oid));
      return ffi_new_object(oid_obj, std::move(oid_ptr));
   });
}

References BOTAN_FFI_ERROR_BAD_PARAMETER, BOTAN_FFI_ERROR_NULL_POINTER, Botan_FFI::ffi_guard_thunk(), Botan_FFI::ffi_new_object(), and Botan::OID::from_string().

botan_oid_register()

int botan_oid_register	(	botan_asn1_oid_t	oid,
		const char *	name )

Registers an OID so that it may later be retrieved by name

Returns

negative number on error, or zero on success

Definition at line 40 of file ffi_oid.cpp.

                                                               {
   return BOTAN_FFI_VISIT(oid, [=](const auto& o) -> int {
      if(name == nullptr) {
         return BOTAN_FFI_ERROR_NULL_POINTER;
      }
      Botan::OID::register_oid(o, name);
      return BOTAN_FFI_SUCCESS;
   });
}

References BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_SUCCESS, BOTAN_FFI_VISIT, and Botan::OID::register_oid().

botan_oid_view_name()

int botan_oid_view_name	(	botan_asn1_oid_t	oid,
		botan_view_ctx	ctx,
		botan_view_str_fn	view )

View an OIDs registered name if it exists, else its dot notation

Definition at line 54 of file ffi_oid.cpp.

                                                                                          {
   return BOTAN_FFI_VISIT(
      oid, [=](const auto& o) -> int { return invoke_view_callback(view, ctx, o.to_formatted_string()); });
}

References BOTAN_FFI_VISIT, and Botan_FFI::invoke_view_callback().

botan_oid_view_string()

int botan_oid_view_string	(	botan_asn1_oid_t	oid,
		botan_view_ctx	ctx,
		botan_view_str_fn	view )

View an OID in dot notation

Definition at line 50 of file ffi_oid.cpp.

                                                                                            {
   return BOTAN_FFI_VISIT(oid, [=](const auto& o) -> int { return invoke_view_callback(view, ctx, o.to_string()); });
}

References BOTAN_FFI_VISIT, and Botan_FFI::invoke_view_callback().

botan_pbkdf()

int botan_pbkdf	(	const char *	pbkdf_algo,
		uint8_t	out[],
		size_t	out_len,
		const char *	passphrase,
		const uint8_t	salt[],
		size_t	salt_len,
		size_t	iterations )

Definition at line 23 of file ffi_kdf.cpp.

                                   {
   return botan_pwdhash(algo, iterations, 0, 0, out, out_len, pass, 0, salt, salt_len);
}

References botan_pwdhash().

botan_pbkdf_timed()

int botan_pbkdf_timed	(	const char *	pbkdf_algo,
		uint8_t	out[],
		size_t	out_len,
		const char *	passphrase,
		const uint8_t	salt[],
		size_t	salt_len,
		size_t	milliseconds_to_run,
		size_t *	out_iterations_used )

Derive a key from a passphrase, running until msec time has elapsed.

Parameters

pbkdf_algo	PBKDF algorithm, e.g., "PBKDF2(SHA-256)"
out	buffer to store the derived key, must be of out_len bytes
out_len	the desired length of the key to produce
passphrase	the password to derive the key from
salt	a randomly chosen salt
salt_len	length of salt in bytes
milliseconds_to_run	if iterations is zero, then instead the PBKDF is run until milliseconds_to_run milliseconds has passed
out_iterations_used	set to the number iterations executed

Returns

0 on success, a negative value on failure

Deprecated: use

botan_pwdhash_timed(pbkdf_algo, static_cast<uint32_t>(ms_to_run), iterations_used, nullptr, nullptr, out, out_len, password, 0, salt, salt_len);

Definition at line 33 of file ffi_kdf.cpp.

                                               {
   return botan_pwdhash_timed(algo,
                              static_cast<uint32_t>(ms_to_run),
                              iterations_used,
                              nullptr,
                              nullptr,
                              out,
                              out_len,
                              password,
                              0,
                              salt,
                              salt_len);
}

References botan_pwdhash_timed().

botan_pk_op_decrypt()

int botan_pk_op_decrypt	(	botan_pk_op_decrypt_t	op,
		uint8_t	out[],
		size_t *	out_len,
		const uint8_t	ciphertext[],
		size_t	ciphertext_len )

Definition at line 101 of file ffi_pk_op.cpp.

                                                                                                                {
   return BOTAN_FFI_VISIT(
      op, [=](const auto& o) { return write_vec_output(out, out_len, o.decrypt(ciphertext, ciphertext_len)); });
}

References BOTAN_FFI_VISIT, and Botan_FFI::write_vec_output().

botan_pk_op_decrypt_create()

int botan_pk_op_decrypt_create	(	botan_pk_op_decrypt_t *	op,
		botan_privkey_t	key,
		const char *	padding,
		uint32_t	flags )

Definition at line 70 of file ffi_pk_op.cpp.

                                               {
   if(op == nullptr) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
 
   if(flags != 0) {
      return BOTAN_FFI_ERROR_BAD_FLAG;
   }
 
   return ffi_guard_thunk(__func__, [=]() -> int {
      *op = nullptr;
 
      auto pk = std::make_unique<Botan::PK_Decryptor_EME>(safe_get(key_obj), Botan::system_rng(), padding);
      return ffi_new_object(op, std::move(pk));
   });
}

References BOTAN_FFI_ERROR_BAD_FLAG, BOTAN_FFI_ERROR_NULL_POINTER, Botan_FFI::ffi_guard_thunk(), Botan_FFI::ffi_new_object(), Botan_FFI::safe_get(), and Botan::system_rng().

botan_pk_op_decrypt_destroy()

int botan_pk_op_decrypt_destroy

(

botan_pk_op_decrypt_t

op

)

Returns

0 if success, error if invalid object handle

Definition at line 90 of file ffi_pk_op.cpp.

                                                          {
   return BOTAN_FFI_CHECKED_DELETE(op);
}

References BOTAN_FFI_CHECKED_DELETE.

botan_pk_op_decrypt_output_length()

int botan_pk_op_decrypt_output_length	(	botan_pk_op_decrypt_t	op,
		size_t	ctext_len,
		size_t *	ptext_len )

Definition at line 94 of file ffi_pk_op.cpp.

                                                                                                     {
   if(ptext_len == nullptr) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
   return BOTAN_FFI_VISIT(op, [=](const auto& o) { *ptext_len = o.plaintext_length(ctext_len); });
}

References BOTAN_FFI_ERROR_NULL_POINTER, and BOTAN_FFI_VISIT.

botan_pk_op_encrypt()

int botan_pk_op_encrypt	(	botan_pk_op_encrypt_t	op,
		botan_rng_t	rng,
		uint8_t	out[],
		size_t *	out_len,
		const uint8_t	plaintext[],
		size_t	plaintext_len )

Definition at line 56 of file ffi_pk_op.cpp.

                                              {
   return BOTAN_FFI_VISIT(op, [=](const auto& o) {
      return write_vec_output(out, out_len, o.encrypt(plaintext, plaintext_len, safe_get(rng_obj)));
   });
}

References BOTAN_FFI_VISIT, Botan_FFI::safe_get(), and Botan_FFI::write_vec_output().

botan_pk_op_encrypt_create()

int botan_pk_op_encrypt_create	(	botan_pk_op_encrypt_t *	op,
		botan_pubkey_t	key,
		const char *	padding,
		uint32_t	flags )

Definition at line 28 of file ffi_pk_op.cpp.

                                                                                                                       {
   if(op == nullptr) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
 
   if(flags != 0 && flags != BOTAN_PUBKEY_DER_FORMAT_SIGNATURE) {
      return BOTAN_FFI_ERROR_BAD_FLAG;
   }
 
   return ffi_guard_thunk(__func__, [=]() -> int {
      *op = nullptr;
 
      auto pk = std::make_unique<Botan::PK_Encryptor_EME>(safe_get(key_obj), Botan::system_rng(), padding);
      return ffi_new_object(op, std::move(pk));
   });
}

References BOTAN_FFI_ERROR_BAD_FLAG, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_PUBKEY_DER_FORMAT_SIGNATURE, Botan_FFI::ffi_guard_thunk(), Botan_FFI::ffi_new_object(), Botan_FFI::safe_get(), and Botan::system_rng().

botan_pk_op_encrypt_destroy()

int botan_pk_op_encrypt_destroy

(

botan_pk_op_encrypt_t

op

)

Returns

0 if success, error if invalid object handle

Definition at line 45 of file ffi_pk_op.cpp.

                                                          {
   return BOTAN_FFI_CHECKED_DELETE(op);
}

References BOTAN_FFI_CHECKED_DELETE.

botan_pk_op_encrypt_output_length()

int botan_pk_op_encrypt_output_length	(	botan_pk_op_encrypt_t	op,
		size_t	ptext_len,
		size_t *	ctext_len )

Definition at line 49 of file ffi_pk_op.cpp.

                                                                                                     {
   if(ctext_len == nullptr) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
   return BOTAN_FFI_VISIT(op, [=](const auto& o) { *ctext_len = o.ciphertext_length(ptext_len); });
}

References BOTAN_FFI_ERROR_NULL_POINTER, and BOTAN_FFI_VISIT.

botan_pk_op_kem_decrypt_create()

int botan_pk_op_kem_decrypt_create	(	botan_pk_op_kem_decrypt_t *	op,
		botan_privkey_t	key,
		const char *	kdf )

Definition at line 307 of file ffi_pk_op.cpp.

                                                                                                                {
   if(op == nullptr || padding == nullptr) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
 
   return ffi_guard_thunk(__func__, [=]() -> int {
      auto pk = std::make_unique<Botan::PK_KEM_Decryptor>(safe_get(key_obj), Botan::system_rng(), padding);
      return ffi_new_object(op, std::move(pk));
   });
}

References BOTAN_FFI_ERROR_NULL_POINTER, Botan_FFI::ffi_guard_thunk(), Botan_FFI::ffi_new_object(), Botan_FFI::safe_get(), and Botan::system_rng().

botan_pk_op_kem_decrypt_destroy()

int botan_pk_op_kem_decrypt_destroy

(

botan_pk_op_kem_decrypt_t

op

)

Returns

0 if success, error if invalid object handle

Definition at line 347 of file ffi_pk_op.cpp.

                                                                  {
   return BOTAN_FFI_CHECKED_DELETE(op);
}

References BOTAN_FFI_CHECKED_DELETE.

botan_pk_op_kem_decrypt_shared_key()

int botan_pk_op_kem_decrypt_shared_key	(	botan_pk_op_kem_decrypt_t	op,
		const uint8_t	salt[],
		size_t	salt_len,
		const uint8_t	encapsulated_key[],
		size_t	encapsulated_key_len,
		size_t	desired_shared_key_len,
		uint8_t	shared_key[],
		size_t *	shared_key_len )

Definition at line 331 of file ffi_pk_op.cpp.

                                                               {
   return BOTAN_FFI_VISIT(op, [=](auto& kem) {
      const auto shared_key =
         kem.decrypt(encapsulated_key, encapsulated_key_len, desired_shared_key_len, salt, salt_len);
 
      return write_vec_output(shared_key_out, shared_key_len, shared_key);
   });
}

References BOTAN_FFI_VISIT, and Botan_FFI::write_vec_output().

botan_pk_op_kem_decrypt_shared_key_length()

int botan_pk_op_kem_decrypt_shared_key_length	(	botan_pk_op_kem_decrypt_t	op,
		size_t	desired_shared_key_length,
		size_t *	output_shared_key_length )

Definition at line 318 of file ffi_pk_op.cpp.

                                                                                {
   if(output_shared_key_length == nullptr) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
 
   return BOTAN_FFI_VISIT(op, [=](auto& kem) {
      *output_shared_key_length = kem.shared_key_length(desired_shared_key_length);
      return BOTAN_FFI_SUCCESS;
   });
}

References BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_SUCCESS, and BOTAN_FFI_VISIT.

botan_pk_op_kem_encrypt_create()

int botan_pk_op_kem_encrypt_create	(	botan_pk_op_kem_encrypt_t *	op,
		botan_pubkey_t	key,
		const char *	kdf )

Definition at line 245 of file ffi_pk_op.cpp.

                                                                                                               {
   if(op == nullptr || padding == nullptr) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
 
   return ffi_guard_thunk(__func__, [=]() -> int {
      auto pk = std::make_unique<Botan::PK_KEM_Encryptor>(safe_get(key_obj), padding);
      return ffi_new_object(op, std::move(pk));
   });
}

References BOTAN_FFI_ERROR_NULL_POINTER, Botan_FFI::ffi_guard_thunk(), Botan_FFI::ffi_new_object(), and Botan_FFI::safe_get().

botan_pk_op_kem_encrypt_create_shared_key()

int botan_pk_op_kem_encrypt_create_shared_key	(	botan_pk_op_kem_encrypt_t	op,
		botan_rng_t	rng,
		const uint8_t	salt[],
		size_t	salt_len,
		size_t	desired_shared_key_len,
		uint8_t	shared_key[],
		size_t *	shared_key_len,
		uint8_t	encapsulated_key[],
		size_t *	encapsulated_key_len )

Definition at line 285 of file ffi_pk_op.cpp.

                                                                            {
   return BOTAN_FFI_VISIT(op, [=](auto& kem) {
      const auto result = kem.encrypt(safe_get(rng), desired_shared_key_len, {salt, salt_len});
 
      const int rc = write_vec_output(encapsulated_key_out, encapsulated_key_len, result.encapsulated_shared_key());
 
      if(rc != 0) {
         return rc;
      }
 
      return write_vec_output(shared_key_out, shared_key_len, result.shared_key());
   });
}

References BOTAN_FFI_VISIT, Botan_FFI::safe_get(), and Botan_FFI::write_vec_output().

botan_pk_op_kem_encrypt_destroy()

int botan_pk_op_kem_encrypt_destroy

(

botan_pk_op_kem_encrypt_t

op

)

Returns

0 if success, error if invalid object handle

Definition at line 256 of file ffi_pk_op.cpp.

                                                                  {
   return BOTAN_FFI_CHECKED_DELETE(op);
}

References BOTAN_FFI_CHECKED_DELETE.

botan_pk_op_kem_encrypt_encapsulated_key_length()

int botan_pk_op_kem_encrypt_encapsulated_key_length	(	botan_pk_op_kem_encrypt_t	op,
		size_t *	output_encapsulated_key_length )

Definition at line 273 of file ffi_pk_op.cpp.

                                                                                            {
   if(output_encapsulated_key_length == nullptr) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
 
   return BOTAN_FFI_VISIT(op, [=](auto& kem) {
      *output_encapsulated_key_length = kem.encapsulated_key_length();
      return BOTAN_FFI_SUCCESS;
   });
}

References BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_SUCCESS, and BOTAN_FFI_VISIT.

botan_pk_op_kem_encrypt_shared_key_length()

int botan_pk_op_kem_encrypt_shared_key_length	(	botan_pk_op_kem_encrypt_t	op,
		size_t	desired_shared_key_length,
		size_t *	output_shared_key_length )

Definition at line 260 of file ffi_pk_op.cpp.

                                                                                {
   if(output_shared_key_length == nullptr) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
 
   return BOTAN_FFI_VISIT(op, [=](auto& kem) {
      *output_shared_key_length = kem.shared_key_length(desired_shared_key_length);
      return BOTAN_FFI_SUCCESS;
   });
}

References BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_SUCCESS, and BOTAN_FFI_VISIT.

botan_pk_op_key_agreement()

int botan_pk_op_key_agreement	(	botan_pk_op_ka_t	op,
		uint8_t	out[],
		size_t *	out_len,
		const uint8_t	other_key[],
		size_t	other_key_len,
		const uint8_t	salt[],
		size_t	salt_len )

Definition at line 232 of file ffi_pk_op.cpp.

                                               {
   return BOTAN_FFI_VISIT(op, [=](const auto& o) {
      auto k = o.derive_key(*out_len, other_key, other_key_len, salt, salt_len).bits_of();
      return write_vec_output(out, out_len, k);
   });
}

References BOTAN_FFI_VISIT, and Botan_FFI::write_vec_output().

botan_pk_op_key_agreement_create()

int botan_pk_op_key_agreement_create	(	botan_pk_op_ka_t *	op,
		botan_privkey_t	key,
		const char *	kdf,
		uint32_t	flags )

Definition at line 188 of file ffi_pk_op.cpp.

                                                                                                                     {
   if(op == nullptr) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
 
   if(flags != 0) {
      return BOTAN_FFI_ERROR_BAD_FLAG;
   }
 
   return ffi_guard_thunk(__func__, [=]() -> int {
      *op = nullptr;
      auto pk = std::make_unique<Botan::PK_Key_Agreement>(safe_get(key_obj), Botan::system_rng(), kdf);
      return ffi_new_object(op, std::move(pk));
   });
}

References BOTAN_FFI_ERROR_BAD_FLAG, BOTAN_FFI_ERROR_NULL_POINTER, Botan_FFI::ffi_guard_thunk(), Botan_FFI::ffi_new_object(), Botan_FFI::safe_get(), and Botan::system_rng().

botan_pk_op_key_agreement_destroy()

int botan_pk_op_key_agreement_destroy

(

botan_pk_op_ka_t

op

)

Returns

0 if success, error if invalid object handle

Definition at line 204 of file ffi_pk_op.cpp.

                                                           {
   return BOTAN_FFI_CHECKED_DELETE(op);
}

References BOTAN_FFI_CHECKED_DELETE.

botan_pk_op_key_agreement_export_public()

int botan_pk_op_key_agreement_export_public	(	botan_privkey_t	key,
		uint8_t	out[],
		size_t *	out_len )

Definition at line 208 of file ffi_pk_op.cpp.

                                                                                                 {
   return copy_view_bin(out, out_len, botan_pk_op_key_agreement_view_public, key);
}

References botan_pk_op_key_agreement_view_public(), and Botan_FFI::copy_view_bin().

botan_pk_op_key_agreement_size()

int botan_pk_op_key_agreement_size	(	botan_pk_op_ka_t	op,
		size_t *	out_len )

Definition at line 222 of file ffi_pk_op.cpp.

                                                                         {
   return BOTAN_FFI_VISIT(op, [=](const auto& o) {
      if(out_len == nullptr) {
         return BOTAN_FFI_ERROR_NULL_POINTER;
      }
      *out_len = o.agreed_value_size();
      return BOTAN_FFI_SUCCESS;
   });
}

References BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_SUCCESS, and BOTAN_FFI_VISIT.

botan_pk_op_key_agreement_view_public()

int botan_pk_op_key_agreement_view_public	(	botan_privkey_t	key,
		botan_view_ctx	ctx,
		botan_view_bin_fn	view )

Definition at line 212 of file ffi_pk_op.cpp.

                                                                                                           {
   return BOTAN_FFI_VISIT(key, [=](const auto& k) -> int {
      if(auto kak = dynamic_cast<const Botan::PK_Key_Agreement_Key*>(&k)) {
         return invoke_view_callback(view, ctx, kak->public_value());
      } else {
         return BOTAN_FFI_ERROR_INVALID_INPUT;
      }
   });
}

References BOTAN_FFI_ERROR_INVALID_INPUT, BOTAN_FFI_VISIT, and Botan_FFI::invoke_view_callback().

Referenced by botan_pk_op_key_agreement_export_public().

botan_pk_op_sign_create()

int botan_pk_op_sign_create	(	botan_pk_op_sign_t *	op,
		botan_privkey_t	key,
		const char *	hash_and_padding,
		uint32_t	flags )

Definition at line 110 of file ffi_pk_op.cpp.

                                                                                                               {
   if(op == nullptr) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
 
   if(flags != 0 && flags != BOTAN_PUBKEY_DER_FORMAT_SIGNATURE) {
      return BOTAN_FFI_ERROR_BAD_FLAG;
   }
 
   return ffi_guard_thunk(__func__, [=]() -> int {
      *op = nullptr;
 
      const bool use_der = (flags & BOTAN_PUBKEY_DER_FORMAT_SIGNATURE) != 0;
      auto format = use_der ? Botan::Signature_Format::DerSequence : Botan::Signature_Format::Standard;
 
      auto pk = std::make_unique<Botan::PK_Signer>(safe_get(key_obj), Botan::system_rng(), hash, format);
      return ffi_new_object(op, std::move(pk));
   });
}

References BOTAN_FFI_ERROR_BAD_FLAG, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_PUBKEY_DER_FORMAT_SIGNATURE, Botan::DerSequence, Botan_FFI::ffi_guard_thunk(), Botan_FFI::ffi_new_object(), Botan_FFI::safe_get(), Botan::Standard, and Botan::system_rng().

botan_pk_op_sign_destroy()

int botan_pk_op_sign_destroy

(

botan_pk_op_sign_t

op

)

Returns

0 if success, error if invalid object handle

Definition at line 130 of file ffi_pk_op.cpp.

                                                    {
   return BOTAN_FFI_CHECKED_DELETE(op);
}

References BOTAN_FFI_CHECKED_DELETE.

botan_pk_op_sign_finish()

int botan_pk_op_sign_finish	(	botan_pk_op_sign_t	op,
		botan_rng_t	rng,
		uint8_t	sig[],
		size_t *	sig_len )

Definition at line 146 of file ffi_pk_op.cpp.

                                                                                                        {
   return BOTAN_FFI_VISIT(op, [=](auto& o) { return write_vec_output(out, out_len, o.signature(safe_get(rng_obj))); });
}

References BOTAN_FFI_VISIT, Botan_FFI::safe_get(), and Botan_FFI::write_vec_output().

botan_pk_op_sign_output_length()

int botan_pk_op_sign_output_length	(	botan_pk_op_sign_t	op,
		size_t *	olen )

Definition at line 134 of file ffi_pk_op.cpp.

                                                                           {
   if(sig_len == nullptr) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
 
   return BOTAN_FFI_VISIT(op, [=](const auto& o) { *sig_len = o.signature_length(); });
}

References BOTAN_FFI_ERROR_NULL_POINTER, and BOTAN_FFI_VISIT.

botan_pk_op_sign_update()

int botan_pk_op_sign_update	(	botan_pk_op_sign_t	op,
		const uint8_t	in[],
		size_t	in_len )

Definition at line 142 of file ffi_pk_op.cpp.

                                                                                      {
   return BOTAN_FFI_VISIT(op, [=](auto& o) { o.update(in, in_len); });
}

References BOTAN_FFI_VISIT.

botan_pk_op_verify_create()

int botan_pk_op_verify_create	(	botan_pk_op_verify_t *	op,
		botan_pubkey_t	key,
		const char *	hash_and_padding,
		uint32_t	flags )

Definition at line 150 of file ffi_pk_op.cpp.

                                                                                                                  {
   if(op == nullptr) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
 
   if(flags != 0 && flags != BOTAN_PUBKEY_DER_FORMAT_SIGNATURE) {
      return BOTAN_FFI_ERROR_BAD_FLAG;
   }
 
   return ffi_guard_thunk(__func__, [=]() -> int {
      *op = nullptr;
      const bool use_der = (flags & BOTAN_PUBKEY_DER_FORMAT_SIGNATURE) != 0;
      auto format = use_der ? Botan::Signature_Format::DerSequence : Botan::Signature_Format::Standard;
      auto pk = std::make_unique<Botan::PK_Verifier>(safe_get(key_obj), hash, format);
      return ffi_new_object(op, std::move(pk));
   });
}

References BOTAN_FFI_ERROR_BAD_FLAG, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_PUBKEY_DER_FORMAT_SIGNATURE, Botan::DerSequence, Botan_FFI::ffi_guard_thunk(), Botan_FFI::ffi_new_object(), Botan_FFI::safe_get(), and Botan::Standard.

botan_pk_op_verify_destroy()

int botan_pk_op_verify_destroy

(

botan_pk_op_verify_t

op

)

Returns

0 if success, error if invalid object handle

Definition at line 168 of file ffi_pk_op.cpp.

                                                        {
   return BOTAN_FFI_CHECKED_DELETE(op);
}

References BOTAN_FFI_CHECKED_DELETE.

botan_pk_op_verify_finish()

int botan_pk_op_verify_finish	(	botan_pk_op_verify_t	op,
		const uint8_t	sig[],
		size_t	sig_len )

Definition at line 176 of file ffi_pk_op.cpp.

                                                                                            {
   return BOTAN_FFI_VISIT(op, [=](auto& o) {
      const bool legit = o.check_signature(sig, sig_len);
 
      if(legit) {
         return BOTAN_FFI_SUCCESS;
      } else {
         return BOTAN_FFI_INVALID_VERIFIER;
      }
   });
}

References BOTAN_FFI_INVALID_VERIFIER, BOTAN_FFI_SUCCESS, and BOTAN_FFI_VISIT.

botan_pk_op_verify_update()

int botan_pk_op_verify_update	(	botan_pk_op_verify_t	op,
		const uint8_t	in[],
		size_t	in_len )

Definition at line 172 of file ffi_pk_op.cpp.

                                                                                          {
   return BOTAN_FFI_VISIT(op, [=](auto& o) { o.update(in, in_len); });
}

References BOTAN_FFI_VISIT.

botan_pkcs_hash_id()

int botan_pkcs_hash_id	(	const char *	hash_name,
		uint8_t	pkcs_id[],
		size_t *	pkcs_id_len )

Signature Scheme Utility Functions

Definition at line 469 of file ffi_pkey.cpp.

                                                                                      {
   if(hash_name == nullptr) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
#if defined(BOTAN_HAS_HASH_ID)
   return ffi_guard_thunk(__func__, [=]() -> int {
      const std::vector<uint8_t> hash_id = Botan::pkcs_hash_id(hash_name);
      return write_output(pkcs_id, pkcs_id_len, hash_id.data(), hash_id.size());
   });
#else
   BOTAN_UNUSED(hash_name, pkcs_id, pkcs_id_len);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_UNUSED, Botan_FFI::ffi_guard_thunk(), Botan::pkcs_hash_id(), and Botan_FFI::write_output().

botan_privkey_algo_name()

int botan_privkey_algo_name	(	botan_privkey_t	key,
		char	out[],
		size_t *	out_len )

Definition at line 162 of file ffi_pkey.cpp.

                                                                              {
   return BOTAN_FFI_VISIT(key, [=](const auto& k) { return write_str_output(out, out_len, k.algo_name()); });
}

References BOTAN_FFI_VISIT, and Botan_FFI::write_str_output().

botan_privkey_check_key()

int botan_privkey_check_key	(	botan_privkey_t	key,
		botan_rng_t	rng,
		uint32_t	flags )

Definition at line 178 of file ffi_pkey.cpp.

                                                                                  {
   const bool strong = (flags & BOTAN_CHECK_KEY_EXPENSIVE_TESTS) != 0;
   return BOTAN_FFI_VISIT(key, [=](const auto& k) {
      return (k.check_key(safe_get(rng), strong) == true) ? 0 : BOTAN_FFI_ERROR_INVALID_INPUT;
   });
}

References BOTAN_CHECK_KEY_EXPENSIVE_TESTS, BOTAN_FFI_ERROR_INVALID_INPUT, BOTAN_FFI_VISIT, and Botan_FFI::safe_get().

botan_privkey_create()

int botan_privkey_create	(	botan_privkey_t *	key,
		const char *	algo_name,
		const char *	algo_params,
		botan_rng_t	rng )

Create a new private key

Parameters

key	the new object will be placed here
algo_name	something like "RSA" or "ECDSA"
algo_params	is specific to the algorithm. For RSA, specifies the modulus bit length. For ECC is the name of the curve.
Random Number Generators	a random number generator

Definition at line 30 of file ffi_pkey.cpp.

                                              {
   // TODO(Botan4) remove this implicit algorithm choice and reject nullptr algo_name
   if(algo_name == nullptr) {
      return botan_privkey_create(key_obj, "RSA", algo_params, rng_obj);
   }
 
   return ffi_guard_thunk(__func__, [=]() -> int {
      if(key_obj == nullptr) {
         return BOTAN_FFI_ERROR_NULL_POINTER;
      }
 
      *key_obj = nullptr;
      if(rng_obj == nullptr) {
         return BOTAN_FFI_ERROR_NULL_POINTER;
      }
 
      const std::string params(algo_params != nullptr ? algo_params : "");
 
      Botan::RandomNumberGenerator& rng = safe_get(rng_obj);
 
      if(auto key = Botan::create_private_key(algo_name, rng, params)) {
         return ffi_new_object(key_obj, std::move(key));
      } else {
         return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
      }
   });
}

References BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, botan_privkey_create(), Botan::create_private_key(), Botan_FFI::ffi_guard_thunk(), Botan_FFI::ffi_new_object(), and Botan_FFI::safe_get().

Referenced by botan_privkey_create(), botan_privkey_create_dh(), botan_privkey_create_ecdh(), botan_privkey_create_ecdsa(), botan_privkey_create_mceliece(), and botan_privkey_create_rsa().

botan_privkey_create_dh()

int botan_privkey_create_dh	(	botan_privkey_t *	key,
		botan_rng_t	rng,
		const char *	param )

Definition at line 598 of file ffi_pkey_algs.cpp.

                                                                                                  {
   return botan_privkey_create(key_obj, "DH", param_str, rng_obj);
}

References botan_privkey_create().

botan_privkey_create_ecdh()

int botan_privkey_create_ecdh	(	botan_privkey_t *	key,
		botan_rng_t	rng,
		const char *	params )

Definition at line 638 of file ffi_pkey_algs.cpp.

                                                                                                    {
   if(Botan::any_null_pointers(key_obj, param_str)) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
   *key_obj = nullptr;
 
   const std::string params(param_str);
 
   if(params == "X25519" || params == "x25519" || params == "curve25519") {
      return botan_privkey_create(key_obj, "X25519", "", rng_obj);
   }
 
   if(params == "X448" || params == "x448") {
      return botan_privkey_create(key_obj, "X448", "", rng_obj);
   }
 
   return botan_privkey_create(key_obj, "ECDH", param_str, rng_obj);
}

References Botan::any_null_pointers(), BOTAN_FFI_ERROR_NULL_POINTER, and botan_privkey_create().

botan_privkey_create_ecdsa()

int botan_privkey_create_ecdsa	(	botan_privkey_t *	key,
		botan_rng_t	rng,
		const char *	params )

Definition at line 439 of file ffi_pkey_algs.cpp.

                                                                                                     {
   return botan_privkey_create(key_obj, "ECDSA", param_str, rng_obj);
}

References botan_privkey_create().

botan_privkey_create_mceliece()

int botan_privkey_create_mceliece	(	botan_privkey_t *	key,
		botan_rng_t	rng,
		size_t	n,
		size_t	t )

Definition at line 1559 of file ffi_pkey_algs.cpp.

                                                                                                     {
   const std::string mce_params = std::to_string(n) + "," + std::to_string(t);
   return botan_privkey_create(key_obj, "McEliece", mce_params.c_str(), rng_obj);
}

References botan_privkey_create().

botan_privkey_create_rsa()

int botan_privkey_create_rsa	(	botan_privkey_t *	key,
		botan_rng_t	rng,
		size_t	n_bits )

Definition at line 228 of file ffi_pkey_algs.cpp.

                                                                                           {
   if(n_bits < 1024 || n_bits > 16 * 1024) {
      return BOTAN_FFI_ERROR_BAD_PARAMETER;
   }
 
   const std::string n_str = std::to_string(n_bits);
 
   return botan_privkey_create(key_obj, "RSA", n_str.c_str(), rng_obj);
}

References BOTAN_FFI_ERROR_BAD_PARAMETER, and botan_privkey_create().

botan_privkey_destroy()

int botan_privkey_destroy

(

botan_privkey_t

key

)

Returns

0 if success, error if invalid object handle

Definition at line 120 of file ffi_pkey.cpp.

                                               {
   return BOTAN_FFI_CHECKED_DELETE(key);
}

References BOTAN_FFI_CHECKED_DELETE.

botan_privkey_dsa_get_x()

int botan_privkey_dsa_get_x	(	botan_mp_t	n,
		botan_privkey_t	key )

Definition at line 419 of file ffi_pkey_algs.cpp.

                                                               {
   return botan_privkey_get_field(x, key, "x");
}

References botan_privkey_get_field().

botan_privkey_ed25519_get_privkey()

int botan_privkey_ed25519_get_privkey	(	botan_privkey_t	key,
		uint8_t	output[64] )

Definition at line 932 of file ffi_pkey_algs.cpp.

                                                                               {
   if(output == nullptr) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
#if defined(BOTAN_HAS_ED25519)
   return BOTAN_FFI_VISIT(key, [=](const auto& k) {
      if(auto ed = dynamic_cast<const Botan::Ed25519_PrivateKey*>(&k)) {
         const auto ed_key = ed->raw_private_key_bits();
         if(ed_key.size() != 64) {
            return BOTAN_FFI_ERROR_INSUFFICIENT_BUFFER_SPACE;
         }
         Botan::copy_mem(output, ed_key.data(), ed_key.size());
         return BOTAN_FFI_SUCCESS;
      } else {
         return BOTAN_FFI_ERROR_BAD_PARAMETER;
      }
   });
#else
   BOTAN_UNUSED(key, output);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References BOTAN_FFI_ERROR_BAD_PARAMETER, BOTAN_FFI_ERROR_INSUFFICIENT_BUFFER_SPACE, BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_SUCCESS, BOTAN_FFI_VISIT, BOTAN_UNUSED, and Botan::copy_mem().

botan_privkey_ed448_get_privkey()

int botan_privkey_ed448_get_privkey	(	botan_privkey_t	key,
		uint8_t	output[57] )

Definition at line 1012 of file ffi_pkey_algs.cpp.

                                                                             {
   if(output == nullptr) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
#if defined(BOTAN_HAS_ED448)
   return BOTAN_FFI_VISIT(key, [=](const auto& k) {
      if(auto ed = dynamic_cast<const Botan::Ed448_PrivateKey*>(&k)) {
         const auto ed_key = ed->raw_private_key_bits();
         Botan::copy_mem(std::span(output, 57), ed_key);
         return BOTAN_FFI_SUCCESS;
      } else {
         return BOTAN_FFI_ERROR_BAD_PARAMETER;
      }
   });
#else
   BOTAN_UNUSED(key, output);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References BOTAN_FFI_ERROR_BAD_PARAMETER, BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_SUCCESS, BOTAN_FFI_VISIT, BOTAN_UNUSED, and Botan::copy_mem().

botan_privkey_export()

int botan_privkey_export	(	botan_privkey_t	key,
		uint8_t	out[],
		size_t *	out_len,
		uint32_t	flags )

On input *out_len is number of bytes in out[] On output *out_len is number of bytes written (or required) If out is not big enough no output is written, *out_len is set and 1 is returned Returns 0 on success and sets If some other error occurs a negative integer is returned.

Definition at line 212 of file ffi_pkey.cpp.

                                                                                              {
   if(flags == BOTAN_PRIVKEY_EXPORT_FLAG_DER) {
      return copy_view_bin(out, out_len, botan_privkey_view_der, key);
   } else if(flags == BOTAN_PRIVKEY_EXPORT_FLAG_PEM) {
      return copy_view_str(out, out_len, botan_privkey_view_pem, key);
   } else if(flags == BOTAN_PRIVKEY_EXPORT_FLAG_RAW) {
      return copy_view_bin(out, out_len, botan_privkey_view_raw, key);
   } else {
      return BOTAN_FFI_ERROR_BAD_FLAG;
   }
}

References BOTAN_FFI_ERROR_BAD_FLAG, BOTAN_PRIVKEY_EXPORT_FLAG_DER, BOTAN_PRIVKEY_EXPORT_FLAG_PEM, BOTAN_PRIVKEY_EXPORT_FLAG_RAW, botan_privkey_view_der(), botan_privkey_view_pem(), botan_privkey_view_raw(), Botan_FFI::copy_view_bin(), and Botan_FFI::copy_view_str().

botan_privkey_export_encrypted()

int botan_privkey_export_encrypted	(	botan_privkey_t	key,
		uint8_t	out[],
		size_t *	out_len,
		botan_rng_t	rng,
		const char *	passphrase,
		const char *	encryption_algo,
		uint32_t	flags )

Set encryption_algo to NULL or "" to have the library choose a default (recommended)

Definition at line 239 of file ffi_pkey.cpp.

                                                   {
   return botan_privkey_export_encrypted_pbkdf_iter(key, out, out_len, rng_obj, pass, 100000, nullptr, nullptr, flags);
}

References botan_privkey_export_encrypted_pbkdf_iter().

botan_privkey_export_encrypted_pbkdf_iter()

int botan_privkey_export_encrypted_pbkdf_iter	(	botan_privkey_t	key,
		uint8_t	out[],
		size_t *	out_len,
		botan_rng_t	rng,
		const char *	passphrase,
		size_t	pbkdf_iterations,
		const char *	cipher_algo,
		const char *	pbkdf_algo,
		uint32_t	flags )

Export a private key using the specified number of iterations.

Definition at line 326 of file ffi_pkey.cpp.

                                                              {
   if(flags == BOTAN_PRIVKEY_EXPORT_FLAG_DER) {
      return copy_view_bin(
         out, out_len, botan_privkey_view_encrypted_der, key, rng, passphrase, cipher, pbkdf_algo, pbkdf_iter);
   } else if(flags == BOTAN_PRIVKEY_EXPORT_FLAG_PEM) {
      return copy_view_str(
         out, out_len, botan_privkey_view_encrypted_pem, key, rng, passphrase, cipher, pbkdf_algo, pbkdf_iter);
   } else {
      return BOTAN_FFI_ERROR_BAD_FLAG;
   }
}

References BOTAN_FFI_ERROR_BAD_FLAG, BOTAN_PRIVKEY_EXPORT_FLAG_DER, BOTAN_PRIVKEY_EXPORT_FLAG_PEM, botan_privkey_view_encrypted_der(), botan_privkey_view_encrypted_pem(), Botan_FFI::copy_view_bin(), and Botan_FFI::copy_view_str().

Referenced by botan_privkey_export_encrypted().

botan_privkey_export_encrypted_pbkdf_msec()

int botan_privkey_export_encrypted_pbkdf_msec	(	botan_privkey_t	key,
		uint8_t	out[],
		size_t *	out_len,
		botan_rng_t	rng,
		const char *	passphrase,
		uint32_t	pbkdf_msec_runtime,
		size_t *	pbkdf_iterations_out,
		const char *	cipher_algo,
		const char *	pbkdf_algo,
		uint32_t	flags )

Definition at line 249 of file ffi_pkey.cpp.

                                                              {
   if(pbkdf_iters_out != nullptr) {
      *pbkdf_iters_out = 0;
   }
 
   if(flags == BOTAN_PRIVKEY_EXPORT_FLAG_DER) {
      return copy_view_bin(
         out, out_len, botan_privkey_view_encrypted_der_timed, key, rng, passphrase, cipher, pbkdf_hash, pbkdf_msec);
   } else if(flags == BOTAN_PRIVKEY_EXPORT_FLAG_PEM) {
      return copy_view_str(
         out, out_len, botan_privkey_view_encrypted_pem_timed, key, rng, passphrase, cipher, pbkdf_hash, pbkdf_msec);
   } else {
      return BOTAN_FFI_ERROR_BAD_FLAG;
   }
}

References BOTAN_FFI_ERROR_BAD_FLAG, BOTAN_PRIVKEY_EXPORT_FLAG_DER, BOTAN_PRIVKEY_EXPORT_FLAG_PEM, botan_privkey_view_encrypted_der_timed(), botan_privkey_view_encrypted_pem_timed(), Botan_FFI::copy_view_bin(), and Botan_FFI::copy_view_str().

botan_privkey_export_pubkey()

int botan_privkey_export_pubkey	(	botan_pubkey_t *	out,
		botan_privkey_t	in )

Definition at line 152 of file ffi_pkey.cpp.

                                                                                 {
   if(pubout == nullptr) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
   return ffi_guard_thunk(__func__, [=]() -> int {
      auto public_key = safe_get(key_obj).public_key();
      return ffi_new_object(pubout, std::move(public_key));
   });
}

References BOTAN_FFI_ERROR_NULL_POINTER, Botan_FFI::ffi_guard_thunk(), Botan_FFI::ffi_new_object(), and Botan_FFI::safe_get().

botan_privkey_get_field()

int botan_privkey_get_field	(	botan_mp_t	output,
		botan_privkey_t	key,
		const char *	field_name )

Definition at line 216 of file ffi_pkey_algs.cpp.

                                                                                                 {
   if(field_name_cstr == nullptr) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
 
   const std::string field_name(field_name_cstr);
 
   return BOTAN_FFI_VISIT(key, [=](const auto& k) { safe_get(output) = privkey_get_field(k, field_name); });
}

References BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_VISIT, and Botan_FFI::safe_get().

Referenced by botan_privkey_dsa_get_x(), botan_privkey_rsa_get_d(), botan_privkey_rsa_get_e(), botan_privkey_rsa_get_n(), botan_privkey_rsa_get_p(), and botan_privkey_rsa_get_q().

botan_privkey_load()

int botan_privkey_load	(	botan_privkey_t *	key,
		botan_rng_t	rng,
		const uint8_t	bits[],
		size_t	len,
		const char *	password )

Generates DSA key pair. Gives to a caller control over key length and order of a subgroup 'q'.

Parameters

key	handler to the resulting key
Random Number Generators	initialized PRNG
pbits	length of the key in bits. Must be between in range (1024, 3072) and multiple of 64. Bit size of the prime 'p'
qbits	order of the subgroup. Must be in range (160, 256) and multiple of 8

Returns

BOTAN_FFI_SUCCESS Success, key' initialized with DSA key @returns BOTAN_FFI_ERROR_NULL_POINTER either key' or Random Number Generators' is NULL @returns BOTAN_FFI_ERROR_BAD_PARAMETER unexpected value for either pbits' or `qbits'

BOTAN_FFI_ERROR_NOT_IMPLEMENTED functionality not implemented

*/ int botan_privkey_create_dsa(botan_privkey_t* key, botan_rng_t rng, size_t pbits, size_t qbits);

/** Generates ElGamal key pair. Caller has a control over key length and order of a subgroup 'q'. Function is able to use two types of primes:

• if pbits-1 == qbits then safe primes are used for key generation
• otherwise generation uses group of prime order

Parameters

key	handler to the resulting key
Random Number Generators	initialized PRNG
pbits	length of the key in bits. Must be at least 1024
qbits	order of the subgroup. Must be at least 160

Returns

BOTAN_FFI_SUCCESS Success, key' initialized with DSA key @returns BOTAN_FFI_ERROR_NULL_POINTER either key' or Random Number Generators' is NULL @returns BOTAN_FFI_ERROR_BAD_PARAMETER unexpected value for either pbits' or `qbits'

BOTAN_FFI_ERROR_NOT_IMPLEMENTED functionality not implemented

*/

int botan_privkey_create_elgamal(botan_privkey_t* key, botan_rng_t rng, size_t pbits, size_t qbits);

/** Input currently assumed to be PKCS #8 structure; Set password to NULL to indicate no encryption expected Starting in 2.8.0, the rng parameter is unused and may be set to null

Definition at line 87 of file ffi_pkey.cpp.

                                                                                                      {
   BOTAN_UNUSED(rng_obj);
 
   if(key == nullptr) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
 
   *key = nullptr;
 
   if(bits == nullptr && len > 0) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
 
   return ffi_guard_thunk(__func__, [=]() -> int {
      Botan::DataSource_Memory src(bits, len);
 
      std::unique_ptr<Botan::Private_Key> pkcs8;
 
      if(password == nullptr) {
         pkcs8 = Botan::PKCS8::load_key(src);
      } else {
         pkcs8 = Botan::PKCS8::load_key(src, std::string(password));
      }
 
      if(pkcs8) {
         ffi_new_object(key, std::move(pkcs8));
         return BOTAN_FFI_SUCCESS;
      }
      return BOTAN_FFI_ERROR_UNKNOWN_ERROR;
   });
}

References BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_ERROR_UNKNOWN_ERROR, BOTAN_FFI_SUCCESS, BOTAN_UNUSED, Botan_FFI::ffi_guard_thunk(), Botan_FFI::ffi_new_object(), and Botan::PKCS8::load_key().

botan_privkey_load_classic_mceliece()

int botan_privkey_load_classic_mceliece	(	botan_privkey_t *	key,
		const uint8_t	privkey[],
		size_t	key_len,
		const char *	cmce_mode )

Algorithm specific key operation: Classic McEliece

Definition at line 1497 of file ffi_pkey_algs.cpp.

                                                               {
#if defined(BOTAN_HAS_CLASSICMCELIECE)
   if(Botan::any_null_pointers(key, privkey, cmce_mode)) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
 
   *key = nullptr;
 
   return ffi_guard_thunk(__func__, [=]() -> int {
      const auto mode = Botan::Classic_McEliece_Parameter_Set::from_string(cmce_mode);
      auto cmce_key = std::make_unique<Botan::Classic_McEliece_PrivateKey>(std::span{privkey, key_len}, mode);
      return ffi_new_object(key, std::move(cmce_key));
   });
#else
   BOTAN_UNUSED(key, privkey, key_len, cmce_mode);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References Botan::any_null_pointers(), BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_UNUSED, Botan_FFI::ffi_guard_thunk(), Botan_FFI::ffi_new_object(), and Botan::Classic_McEliece_Parameter_Set::from_string().

botan_privkey_load_dh()

int botan_privkey_load_dh	(	botan_privkey_t *	key,
		botan_mp_t	p,
		botan_mp_t	g,
		botan_mp_t	x )

Definition at line 602 of file ffi_pkey_algs.cpp.

                                                                                          {
#if defined(BOTAN_HAS_DIFFIE_HELLMAN)
   if(key == nullptr) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
   *key = nullptr;
   return ffi_guard_thunk(__func__, [=]() -> int {
      const Botan::DL_Group group(safe_get(p), safe_get(g));
      auto dh = std::make_unique<Botan::DH_PrivateKey>(group, safe_get(x));
      return ffi_new_object(key, std::move(dh));
   });
#else
   BOTAN_UNUSED(key, p, g, x);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_UNUSED, Botan_FFI::ffi_guard_thunk(), Botan_FFI::ffi_new_object(), and Botan_FFI::safe_get().

botan_privkey_load_dsa()

int botan_privkey_load_dsa	(	botan_privkey_t *	key,
		botan_mp_t	p,
		botan_mp_t	q,
		botan_mp_t	g,
		botan_mp_t	x )

Definition at line 383 of file ffi_pkey_algs.cpp.

                                                                                                         {
#if defined(BOTAN_HAS_DSA)
   if(key == nullptr) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
   *key = nullptr;
 
   return ffi_guard_thunk(__func__, [=]() -> int {
      const Botan::DL_Group group(safe_get(p), safe_get(q), safe_get(g));
      auto dsa = std::make_unique<Botan::DSA_PrivateKey>(group, safe_get(x));
      return ffi_new_object(key, std::move(dsa));
   });
#else
   BOTAN_UNUSED(key, p, q, g, x);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_UNUSED, Botan_FFI::ffi_guard_thunk(), Botan_FFI::ffi_new_object(), and Botan_FFI::safe_get().

botan_privkey_load_ecdh()

int botan_privkey_load_ecdh	(	botan_privkey_t *	key,
		botan_mp_t	scalar,
		const char *	curve_name )

Definition at line 704 of file ffi_pkey_algs.cpp.

                                                                                                   {
#if defined(BOTAN_HAS_ECDH)
   if(Botan::any_null_pointers(key, curve_name)) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
   *key = nullptr;
   return ffi_guard_thunk(__func__, [=]() -> int {
      std::unique_ptr<Botan::ECDH_PrivateKey> p_key;
      const int rc = privkey_load_ec(p_key, safe_get(scalar), curve_name);
      if(rc == BOTAN_FFI_SUCCESS) {
         ffi_new_object(key, std::move(p_key));
      }
      return rc;
   });
#else
   BOTAN_UNUSED(key, scalar, curve_name);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References Botan::any_null_pointers(), BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_SUCCESS, BOTAN_UNUSED, Botan_FFI::ffi_guard_thunk(), Botan_FFI::ffi_new_object(), and Botan_FFI::safe_get().

botan_privkey_load_ecdsa()

int botan_privkey_load_ecdsa	(	botan_privkey_t *	key,
		botan_mp_t	scalar,
		const char *	curve_name )

Definition at line 514 of file ffi_pkey_algs.cpp.

                                                                                                    {
#if defined(BOTAN_HAS_ECDSA)
   if(Botan::any_null_pointers(key, curve_name)) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
   *key = nullptr;
 
   return ffi_guard_thunk(__func__, [=]() -> int {
      std::unique_ptr<Botan::ECDSA_PrivateKey> p_key;
      const int rc = privkey_load_ec(p_key, safe_get(scalar), curve_name);
      if(rc == BOTAN_FFI_SUCCESS) {
         ffi_new_object(key, std::move(p_key));
      }
      return rc;
   });
#else
   BOTAN_UNUSED(key, scalar, curve_name);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References Botan::any_null_pointers(), BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_SUCCESS, BOTAN_UNUSED, Botan_FFI::ffi_guard_thunk(), Botan_FFI::ffi_new_object(), and Botan_FFI::safe_get().

botan_privkey_load_ed25519()

int botan_privkey_load_ed25519	(	botan_privkey_t *	key,
		const uint8_t	privkey[32] )

Definition at line 898 of file ffi_pkey_algs.cpp.

                                                                                {
#if defined(BOTAN_HAS_ED25519)
   if(key == nullptr) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
   *key = nullptr;
   return ffi_guard_thunk(__func__, [=]() -> int {
      auto ed25519 =
         std::make_unique<Botan::Ed25519_PrivateKey>(Botan::Ed25519_PrivateKey::from_seed(std::span{privkey, 32}));
      return ffi_new_object(key, std::move(ed25519));
   });
#else
   BOTAN_UNUSED(key, privkey);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_UNUSED, Botan_FFI::ffi_guard_thunk(), Botan_FFI::ffi_new_object(), and Botan::Ed25519_PrivateKey::from_seed().

botan_privkey_load_ed448()

int botan_privkey_load_ed448	(	botan_privkey_t *	key,
		const uint8_t	privkey[57] )

Definition at line 980 of file ffi_pkey_algs.cpp.

                                                                              {
#if defined(BOTAN_HAS_ED448)
   if(key == nullptr) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
   *key = nullptr;
   return ffi_guard_thunk(__func__, [=]() -> int {
      auto ed448 = std::make_unique<Botan::Ed448_PrivateKey>(std::span(privkey, 57));
      return ffi_new_object(key, std::move(ed448));
   });
#else
   BOTAN_UNUSED(key, privkey);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_UNUSED, Botan_FFI::ffi_guard_thunk(), and Botan_FFI::ffi_new_object().

botan_privkey_load_frodokem()

int botan_privkey_load_frodokem	(	botan_privkey_t *	key,
		const uint8_t	privkey[],
		size_t	key_len,
		const char *	frodo_mode )

Algorithm specific key operation: FrodoKEM

Definition at line 1455 of file ffi_pkey_algs.cpp.

                                                                                                                       {
#if defined(BOTAN_HAS_FRODOKEM)
   if(Botan::any_null_pointers(key, privkey, frodo_mode)) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
 
   *key = nullptr;
 
   return ffi_guard_thunk(__func__, [=]() -> int {
      const auto mode = Botan::FrodoKEMMode(frodo_mode);
      auto frodo_key = std::make_unique<Botan::FrodoKEM_PrivateKey>(std::span{privkey, key_len}, mode);
      return ffi_new_object(key, std::move(frodo_key));
   });
#else
   BOTAN_UNUSED(key, privkey, key_len, frodo_mode);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References Botan::any_null_pointers(), BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_UNUSED, Botan_FFI::ffi_guard_thunk(), and Botan_FFI::ffi_new_object().

botan_privkey_load_kyber()

int botan_privkey_load_kyber	(	botan_privkey_t *	key,
		const uint8_t	privkey[],
		size_t	key_len )

Definition at line 1205 of file ffi_pkey_algs.cpp.

                                                                                            {
#if defined(BOTAN_HAS_KYBER)
   if(Botan::any_null_pointers(key, privkey)) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
   *key = nullptr;
 
   const auto mode = [](size_t len) -> std::optional<Botan::KyberMode> {
      if(len == 1632) {
         return Botan::KyberMode::Kyber512_R3;
      } else if(len == 2400) {
         return Botan::KyberMode::Kyber768_R3;
      } else if(len == 3168) {
         return Botan::KyberMode::Kyber1024_R3;
      } else {
         return {};
      }
   }(key_len);
 
   if(mode.has_value()) {
      return ffi_guard_thunk(__func__, [=]() -> int {
         auto kyber = std::make_unique<Botan::Kyber_PrivateKey>(std::span{privkey, key_len}, *mode);
         return ffi_new_object(key, std::move(kyber));
      });
   } else {
      return BOTAN_FFI_ERROR_BAD_PARAMETER;
   }
#else
   BOTAN_UNUSED(key, key_len, privkey);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References Botan::any_null_pointers(), BOTAN_FFI_ERROR_BAD_PARAMETER, BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_UNUSED, Botan_FFI::ffi_guard_thunk(), Botan_FFI::ffi_new_object(), Botan::KyberMode::Kyber1024_R3, Botan::KyberMode::Kyber512_R3, and Botan::KyberMode::Kyber768_R3.

botan_privkey_load_ml_dsa()

int botan_privkey_load_ml_dsa	(	botan_privkey_t *	key,
		const uint8_t	privkey[],
		size_t	key_len,
		const char *	mldsa_mode )

Definition at line 1355 of file ffi_pkey_algs.cpp.

                                                                                                                     {
#if defined(BOTAN_HAS_ML_DSA)
   if(Botan::any_null_pointers(key, privkey, mldsa_mode)) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
 
   *key = nullptr;
 
   return ffi_guard_thunk(__func__, [=]() -> int {
      auto mode = Botan::ML_DSA_Mode(mldsa_mode);
      if(!mode.is_ml_dsa()) {
         return BOTAN_FFI_ERROR_BAD_PARAMETER;
      }
 
      auto mldsa_key = std::make_unique<Botan::ML_DSA_PrivateKey>(std::span{privkey, key_len}, mode);
      return ffi_new_object(key, std::move(mldsa_key));
   });
#else
   BOTAN_UNUSED(key, key_len, privkey, mldsa_mode);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References Botan::any_null_pointers(), BOTAN_FFI_ERROR_BAD_PARAMETER, BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_UNUSED, Botan_FFI::ffi_guard_thunk(), and Botan_FFI::ffi_new_object().

botan_privkey_load_ml_kem()

int botan_privkey_load_ml_kem	(	botan_privkey_t *	key,
		const uint8_t	privkey[],
		size_t	key_len,
		const char *	mlkem_mode )

Definition at line 1305 of file ffi_pkey_algs.cpp.

                                                                                                                     {
#if defined(BOTAN_HAS_ML_KEM)
   if(Botan::any_null_pointers(key, privkey, mlkem_mode)) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
 
   *key = nullptr;
 
   return ffi_guard_thunk(__func__, [=]() -> int {
      auto mode = Botan::ML_KEM_Mode(mlkem_mode);
      if(!mode.is_ml_kem()) {
         return BOTAN_FFI_ERROR_BAD_PARAMETER;
      }
 
      auto mlkem_key = std::make_unique<Botan::ML_KEM_PrivateKey>(std::span{privkey, key_len}, mode);
      return ffi_new_object(key, std::move(mlkem_key));
   });
#else
   BOTAN_UNUSED(key, key_len, privkey, mlkem_mode);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References Botan::any_null_pointers(), BOTAN_FFI_ERROR_BAD_PARAMETER, BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_UNUSED, Botan_FFI::ffi_guard_thunk(), and Botan_FFI::ffi_new_object().

botan_privkey_load_rsa()

int botan_privkey_load_rsa	(	botan_privkey_t *	key,
		botan_mp_t	p,
		botan_mp_t	q,
		botan_mp_t	e )

Definition at line 238 of file ffi_pkey_algs.cpp.

                                                                                                       {
#if defined(BOTAN_HAS_RSA)
   if(key == nullptr) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
   *key = nullptr;
 
   return ffi_guard_thunk(__func__, [=]() -> int {
      auto rsa = std::make_unique<Botan::RSA_PrivateKey>(safe_get(rsa_p), safe_get(rsa_q), safe_get(rsa_e));
      return ffi_new_object(key, std::move(rsa));
   });
#else
   BOTAN_UNUSED(key, rsa_p, rsa_q, rsa_e);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_UNUSED, Botan_FFI::ffi_guard_thunk(), Botan_FFI::ffi_new_object(), and Botan_FFI::safe_get().

botan_privkey_load_rsa_pkcs1()

int botan_privkey_load_rsa_pkcs1	(	botan_privkey_t *	key,
		const uint8_t	bits[],
		size_t	len )

Definition at line 255 of file ffi_pkey_algs.cpp.

                                                                                         {
#if defined(BOTAN_HAS_RSA)
   if(Botan::any_null_pointers(key, bits)) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
   *key = nullptr;
 
   return ffi_guard_thunk(__func__, [=]() -> int {
      const Botan::AlgorithmIdentifier alg_id("RSA", Botan::AlgorithmIdentifier::USE_NULL_PARAM);
      auto rsa = std::make_unique<Botan::RSA_PrivateKey>(alg_id, std::span{bits, len});
      return ffi_new_object(key, std::move(rsa));
   });
#else
   BOTAN_UNUSED(key, bits, len);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References Botan::any_null_pointers(), BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_UNUSED, Botan_FFI::ffi_guard_thunk(), Botan_FFI::ffi_new_object(), and Botan::AlgorithmIdentifier::USE_NULL_PARAM.

botan_privkey_load_slh_dsa()

int botan_privkey_load_slh_dsa	(	botan_privkey_t *	key,
		const uint8_t	privkey[],
		size_t	key_len,
		const char *	slhdsa_mode )

Definition at line 1405 of file ffi_pkey_algs.cpp.

                                                                                                                       {
#if defined(BOTAN_HAS_SLH_DSA_WITH_SHA2) || defined(BOTAN_HAS_SLH_DSA_WITH_SHAKE)
   if(Botan::any_null_pointers(key, privkey, slhdsa_mode)) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
 
   *key = nullptr;
 
   return ffi_guard_thunk(__func__, [=]() -> int {
      auto mode = Botan::SLH_DSA_Parameters::create(slhdsa_mode);
      if(!mode.is_slh_dsa()) {
         return BOTAN_FFI_ERROR_BAD_PARAMETER;
      }
 
      auto slhdsa_key = std::make_unique<Botan::SLH_DSA_PrivateKey>(std::span{privkey, key_len}, mode);
      return ffi_new_object(key, std::move(slhdsa_key));
   });
#else
   BOTAN_UNUSED(key, key_len, privkey, slhdsa_mode);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References Botan::any_null_pointers(), BOTAN_FFI_ERROR_BAD_PARAMETER, BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_UNUSED, Botan_FFI::ffi_guard_thunk(), and Botan_FFI::ffi_new_object().

botan_privkey_load_sm2()

int botan_privkey_load_sm2	(	botan_privkey_t *	key,
		botan_mp_t	scalar,
		const char *	curve_name )

Definition at line 806 of file ffi_pkey_algs.cpp.

                                                                                                  {
#if defined(BOTAN_HAS_SM2)
   if(Botan::any_null_pointers(key, curve_name)) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
   *key = nullptr;
 
   return ffi_guard_thunk(__func__, [=]() -> int {
      std::unique_ptr<Botan::SM2_PrivateKey> p_key;
      const int rc = privkey_load_ec(p_key, safe_get(scalar), curve_name);
 
      if(rc == BOTAN_FFI_SUCCESS) {
         ffi_new_object(key, std::move(p_key));
      }
      return rc;
   });
#else
   BOTAN_UNUSED(key, scalar, curve_name);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References Botan::any_null_pointers(), BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_SUCCESS, BOTAN_UNUSED, Botan_FFI::ffi_guard_thunk(), Botan_FFI::ffi_new_object(), and Botan_FFI::safe_get().

Referenced by botan_privkey_load_sm2_enc().

botan_privkey_load_sm2_enc()

int botan_privkey_load_sm2_enc	(	botan_privkey_t *	key,
		botan_mp_t	scalar,
		const char *	curve_name )

Definition at line 835 of file ffi_pkey_algs.cpp.

                                                                                                      {
   return botan_privkey_load_sm2(key, scalar, curve_name);
}

References botan_privkey_load_sm2().

botan_privkey_load_x25519()

int botan_privkey_load_x25519	(	botan_privkey_t *	key,
		const uint8_t	privkey[32] )

Definition at line 1054 of file ffi_pkey_algs.cpp.

                                                                               {
#if defined(BOTAN_HAS_X25519)
   if(key == nullptr) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
   *key = nullptr;
   return ffi_guard_thunk(__func__, [=]() -> int {
      auto x25519 = std::make_unique<Botan::X25519_PrivateKey>(std::span{privkey, 32});
      return ffi_new_object(key, std::move(x25519));
   });
#else
   BOTAN_UNUSED(key, privkey);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_UNUSED, Botan_FFI::ffi_guard_thunk(), and Botan_FFI::ffi_new_object().

botan_privkey_load_x448()

int botan_privkey_load_x448	(	botan_privkey_t *	key,
		const uint8_t	privkey[56] )

Definition at line 1130 of file ffi_pkey_algs.cpp.

                                                                             {
#if defined(BOTAN_HAS_X448)
   if(key == nullptr) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
   *key = nullptr;
   return ffi_guard_thunk(__func__, [=]() -> int {
      auto x448 = std::make_unique<Botan::X448_PrivateKey>(std::span{privkey, 56});
      return ffi_new_object(key, std::move(x448));
   });
#else
   BOTAN_UNUSED(key, privkey);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_UNUSED, Botan_FFI::ffi_guard_thunk(), and Botan_FFI::ffi_new_object().

botan_privkey_oid()

int botan_privkey_oid	(	botan_asn1_oid_t *	oid,
		botan_privkey_t	key )

Definition at line 409 of file ffi_pkey.cpp.

                                                                  {
   return BOTAN_FFI_VISIT(key, [=](const auto& k) {
      if(oid == nullptr) {
         return BOTAN_FFI_ERROR_NULL_POINTER;
      }
 
      auto oid_ptr = std::make_unique<Botan::OID>(k.object_identifier());
      ffi_new_object(oid, std::move(oid_ptr));
 
      return BOTAN_FFI_SUCCESS;
   });
}

References BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_SUCCESS, BOTAN_FFI_VISIT, and Botan_FFI::ffi_new_object().

botan_privkey_remaining_operations()

int botan_privkey_remaining_operations	(	botan_privkey_t	key,
		uint64_t *	out )

Gets information on many operations a (stateful) key has remaining and sets

Parameters

out	to that value

Returns

0 on success, a negative value on failure or if the key is not stateful

Definition at line 437 of file ffi_pkey.cpp.

                                                                           {
   return BOTAN_FFI_VISIT(key, [=](const auto& k) {
      if(out == nullptr) {
         return BOTAN_FFI_ERROR_NULL_POINTER;
      }
 
      if(auto remaining = k.remaining_operations()) {
         *out = remaining.value();
         return BOTAN_FFI_SUCCESS;
      } else {
         return BOTAN_FFI_ERROR_NO_VALUE;
      }
   });
}

References BOTAN_FFI_ERROR_NO_VALUE, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_SUCCESS, and BOTAN_FFI_VISIT.

botan_privkey_rsa_get_d()

int botan_privkey_rsa_get_d	(	botan_mp_t	d,
		botan_privkey_t	rsa_key )

Definition at line 323 of file ffi_pkey_algs.cpp.

                                                               {
   return botan_privkey_get_field(d, key, "d");
}

References botan_privkey_get_field().

botan_privkey_rsa_get_e()

int botan_privkey_rsa_get_e	(	botan_mp_t	e,
		botan_privkey_t	rsa_key )

Definition at line 319 of file ffi_pkey_algs.cpp.

                                                               {
   return botan_privkey_get_field(e, key, "e");
}

References botan_privkey_get_field().

botan_privkey_rsa_get_n()

int botan_privkey_rsa_get_n	(	botan_mp_t	n,
		botan_privkey_t	rsa_key )

Definition at line 315 of file ffi_pkey_algs.cpp.

                                                               {
   return botan_privkey_get_field(n, key, "n");
}

References botan_privkey_get_field().

botan_privkey_rsa_get_p()

int botan_privkey_rsa_get_p	(	botan_mp_t	p,
		botan_privkey_t	rsa_key )

Definition at line 307 of file ffi_pkey_algs.cpp.

                                                               {
   return botan_privkey_get_field(p, key, "p");
}

References botan_privkey_get_field().

botan_privkey_rsa_get_privkey()

int botan_privkey_rsa_get_privkey	(	botan_privkey_t	rsa_key,
		uint8_t	out[],
		size_t *	out_len,
		uint32_t	flags )

Definition at line 335 of file ffi_pkey_algs.cpp.

                                                                                                           {
#if defined(BOTAN_HAS_RSA)
   return BOTAN_FFI_VISIT(rsa_key, [=](const auto& k) -> int {
      if(const Botan::RSA_PrivateKey* rsa = dynamic_cast<const Botan::RSA_PrivateKey*>(&k)) {
         if(flags == BOTAN_PRIVKEY_EXPORT_FLAG_DER) {
            return write_vec_output(out, out_len, rsa->private_key_bits());
         } else if(flags == BOTAN_PRIVKEY_EXPORT_FLAG_PEM) {
            // TODO define new generic functions for this
            return write_str_output(reinterpret_cast<char*>(out),
                                    out_len,
                                    Botan::PEM_Code::encode(rsa->private_key_bits(), "RSA PRIVATE KEY"));
         } else {
            return BOTAN_FFI_ERROR_BAD_FLAG;
         }
      } else {
         return BOTAN_FFI_ERROR_BAD_PARAMETER;
      }
   });
#else
   BOTAN_UNUSED(rsa_key, out, out_len, flags);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References BOTAN_FFI_ERROR_BAD_FLAG, BOTAN_FFI_ERROR_BAD_PARAMETER, BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_VISIT, BOTAN_PRIVKEY_EXPORT_FLAG_DER, BOTAN_PRIVKEY_EXPORT_FLAG_PEM, BOTAN_UNUSED, Botan::PEM_Code::encode(), Botan_FFI::write_str_output(), and Botan_FFI::write_vec_output().

botan_privkey_rsa_get_q()

int botan_privkey_rsa_get_q	(	botan_mp_t	q,
		botan_privkey_t	rsa_key )

Definition at line 311 of file ffi_pkey_algs.cpp.

                                                               {
   return botan_privkey_get_field(q, key, "q");
}

References botan_privkey_get_field().

botan_privkey_stateful_operation()

int botan_privkey_stateful_operation	(	botan_privkey_t	key,
		int *	out )

Checks whether a key is stateful and sets

Parameters

out	to 1 if it is, or 0 if the key is not stateful

Returns

0 on success, a negative value on failure

Definition at line 422 of file ffi_pkey.cpp.

                                                                    {
   return BOTAN_FFI_VISIT(key, [=](const auto& k) {
      if(out == nullptr) {
         return BOTAN_FFI_ERROR_NULL_POINTER;
      }
 
      if(k.stateful_operation()) {
         *out = 1;
      } else {
         *out = 0;
      }
      return BOTAN_FFI_SUCCESS;
   });
}

References BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_SUCCESS, and BOTAN_FFI_VISIT.

botan_privkey_view_der()

int botan_privkey_view_der	(	botan_privkey_t	key,
		botan_view_ctx	ctx,
		botan_view_bin_fn	view )

View the private key's DER encoding

Definition at line 224 of file ffi_pkey.cpp.

                                                                                            {
   return BOTAN_FFI_VISIT(key,
                          [=](const auto& k) -> int { return invoke_view_callback(view, ctx, k.private_key_info()); });
}

References BOTAN_FFI_VISIT, and Botan_FFI::invoke_view_callback().

Referenced by botan_privkey_export().

botan_privkey_view_encrypted_der()

int botan_privkey_view_encrypted_der	(	botan_privkey_t	key,
		botan_rng_t	rng,
		const char *	passphrase,
		const char *	cipher_algo,
		const char *	pbkdf_algo,
		size_t	pbkdf_iterations,
		botan_view_ctx	ctx,
		botan_view_bin_fn	view )

View the encryption of a private key (binary DER encoding)

Set cipher_algo, pbkdf_algo to NULL to use defaults Set pbkdf_iterations to 0 to use defaults

Definition at line 346 of file ffi_pkey.cpp.

                                                             {
   if(passphrase == nullptr) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
 
   return BOTAN_FFI_VISIT(key, [=](const auto& k) {
      Botan::RandomNumberGenerator& rng = safe_get(rng_obj);
 
      const std::string cipher = (maybe_cipher ? maybe_cipher : "");
      const std::string pbkdf_algo = (maybe_pbkdf_algo ? maybe_pbkdf_algo : "");
      const size_t pbkdf_iter = (maybe_pbkdf_iterations ? maybe_pbkdf_iterations : 100000);
 
      auto pkcs8 = Botan::PKCS8::BER_encode_encrypted_pbkdf_iter(k, rng, passphrase, pbkdf_iter, cipher, pbkdf_algo);
 
      return invoke_view_callback(view, ctx, pkcs8);
   });
}

References Botan::PKCS8::BER_encode_encrypted_pbkdf_iter(), BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_VISIT, Botan_FFI::invoke_view_callback(), and Botan_FFI::safe_get().

Referenced by botan_privkey_export_encrypted_pbkdf_iter().

botan_privkey_view_encrypted_der_timed()

int botan_privkey_view_encrypted_der_timed	(	botan_privkey_t	key,
		botan_rng_t	rng,
		const char *	passphrase,
		const char *	cipher_algo,
		const char *	pbkdf_algo,
		size_t	pbkdf_runtime_msec,
		botan_view_ctx	ctx,
		botan_view_bin_fn	view )

View the encryption of a private key (binary DER encoding)

Set cipher_algo, pbkdf_algo to NULL to use defaults

Definition at line 274 of file ffi_pkey.cpp.

                                                                   {
   if(passphrase == nullptr) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
 
   return BOTAN_FFI_VISIT(key, [=](const auto& k) {
      const std::chrono::milliseconds pbkdf_time(pbkdf_runtime_msec);
      Botan::RandomNumberGenerator& rng = safe_get(rng_obj);
 
      const std::string cipher = (maybe_cipher ? maybe_cipher : "");
      const std::string pbkdf_algo = (maybe_pbkdf_algo ? maybe_pbkdf_algo : "");
 
      auto pkcs8 =
         Botan::PKCS8::BER_encode_encrypted_pbkdf_msec(k, rng, passphrase, pbkdf_time, nullptr, cipher, pbkdf_algo);
 
      return invoke_view_callback(view, ctx, pkcs8);
   });
}

References Botan::PKCS8::BER_encode_encrypted_pbkdf_msec(), BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_VISIT, Botan_FFI::invoke_view_callback(), and Botan_FFI::safe_get().

Referenced by botan_privkey_export_encrypted_pbkdf_msec().

botan_privkey_view_encrypted_pem()

int botan_privkey_view_encrypted_pem	(	botan_privkey_t	key,
		botan_rng_t	rng,
		const char *	passphrase,
		const char *	cipher_algo,
		const char *	pbkdf_algo,
		size_t	pbkdf_iterations,
		botan_view_ctx	ctx,
		botan_view_str_fn	view )

View the encryption of a private key (PEM encoding)

Set cipher_algo, pbkdf_algo to NULL to use defaults Set pbkdf_iterations to 0 to use defaults

Definition at line 371 of file ffi_pkey.cpp.

                                                             {
   if(passphrase == nullptr) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
 
   return BOTAN_FFI_VISIT(key, [=](const auto& k) {
      Botan::RandomNumberGenerator& rng = safe_get(rng_obj);
 
      const std::string cipher = (maybe_cipher ? maybe_cipher : "");
      const std::string pbkdf_algo = (maybe_pbkdf_algo ? maybe_pbkdf_algo : "");
      const size_t pbkdf_iter = (maybe_pbkdf_iterations ? maybe_pbkdf_iterations : 100000);
 
      auto pkcs8 = Botan::PKCS8::PEM_encode_encrypted_pbkdf_iter(k, rng, passphrase, pbkdf_iter, cipher, pbkdf_algo);
 
      return invoke_view_callback(view, ctx, pkcs8);
   });
}

References BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_VISIT, Botan_FFI::invoke_view_callback(), Botan::PKCS8::PEM_encode_encrypted_pbkdf_iter(), and Botan_FFI::safe_get().

Referenced by botan_privkey_export_encrypted_pbkdf_iter().

botan_privkey_view_encrypted_pem_timed()

int botan_privkey_view_encrypted_pem_timed	(	botan_privkey_t	key,
		botan_rng_t	rng,
		const char *	passphrase,
		const char *	cipher_algo,
		const char *	pbkdf_algo,
		size_t	pbkdf_runtime_msec,
		botan_view_ctx	ctx,
		botan_view_str_fn	view )

View the encryption of a private key (PEM encoding)

Set cipher_algo, pbkdf_algo to NULL to use defaults

Definition at line 300 of file ffi_pkey.cpp.

                                                                   {
   if(passphrase == nullptr) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
 
   return BOTAN_FFI_VISIT(key, [=](const auto& k) {
      const std::chrono::milliseconds pbkdf_time(pbkdf_runtime_msec);
      Botan::RandomNumberGenerator& rng = safe_get(rng_obj);
 
      const std::string cipher = (maybe_cipher ? maybe_cipher : "");
      const std::string pbkdf_algo = (maybe_pbkdf_algo ? maybe_pbkdf_algo : "");
 
      auto pkcs8 =
         Botan::PKCS8::PEM_encode_encrypted_pbkdf_msec(k, rng, passphrase, pbkdf_time, nullptr, cipher, pbkdf_algo);
 
      return invoke_view_callback(view, ctx, pkcs8);
   });
}

References BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_VISIT, Botan_FFI::invoke_view_callback(), Botan::PKCS8::PEM_encode_encrypted_pbkdf_msec(), and Botan_FFI::safe_get().

Referenced by botan_privkey_export_encrypted_pbkdf_msec().

botan_privkey_view_kyber_raw_key()

int botan_privkey_view_kyber_raw_key	(	botan_privkey_t	key,
		botan_view_ctx	ctx,
		botan_view_bin_fn	view )

Definition at line 1271 of file ffi_pkey_algs.cpp.

                                                                                                      {
#if defined(BOTAN_HAS_KYBER)
   return BOTAN_FFI_VISIT(key, [=](const auto& k) -> int {
      if(auto kyber = dynamic_cast<const Botan::Kyber_PrivateKey*>(&k)) {
         return invoke_view_callback(view, ctx, kyber->raw_private_key_bits());
      } else {
         return BOTAN_FFI_ERROR_BAD_PARAMETER;
      }
   });
#else
   BOTAN_UNUSED(key, ctx, view);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References BOTAN_FFI_ERROR_BAD_PARAMETER, BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_VISIT, BOTAN_UNUSED, and Botan_FFI::invoke_view_callback().

botan_privkey_view_pem()

int botan_privkey_view_pem	(	botan_privkey_t	key,
		botan_view_ctx	ctx,
		botan_view_str_fn	view )

View the private key's PEM encoding

Definition at line 229 of file ffi_pkey.cpp.

                                                                                            {
   return BOTAN_FFI_VISIT(
      key, [=](const auto& k) -> int { return invoke_view_callback(view, ctx, Botan::PKCS8::PEM_encode(k)); });
}

References BOTAN_FFI_VISIT, Botan_FFI::invoke_view_callback(), and Botan::PKCS8::PEM_encode().

Referenced by botan_privkey_export().

botan_privkey_view_raw()

int botan_privkey_view_raw	(	botan_privkey_t	key,
		botan_view_ctx	ctx,
		botan_view_bin_fn	view )

View the private key's raw encoding

Definition at line 234 of file ffi_pkey.cpp.

                                                                                            {
   return BOTAN_FFI_VISIT(
      key, [=](const auto& k) -> int { return invoke_view_callback(view, ctx, k.raw_private_key_bits()); });
}

References BOTAN_FFI_VISIT, and Botan_FFI::invoke_view_callback().

Referenced by botan_privkey_export().

botan_privkey_x25519_get_privkey()

int botan_privkey_x25519_get_privkey	(	botan_privkey_t	key,
		uint8_t	output[32] )

Definition at line 1086 of file ffi_pkey_algs.cpp.

                                                                              {
   if(output == nullptr) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
#if defined(BOTAN_HAS_X25519)
   return BOTAN_FFI_VISIT(key, [=](const auto& k) {
      if(auto x25519 = dynamic_cast<const Botan::X25519_PrivateKey*>(&k)) {
         const auto x25519_key = x25519->raw_private_key_bits();
         if(x25519_key.size() != 32) {
            return BOTAN_FFI_ERROR_INSUFFICIENT_BUFFER_SPACE;
         }
         Botan::copy_mem(output, x25519_key.data(), x25519_key.size());
         return BOTAN_FFI_SUCCESS;
      } else {
         return BOTAN_FFI_ERROR_BAD_PARAMETER;
      }
   });
#else
   BOTAN_UNUSED(key, output);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References BOTAN_FFI_ERROR_BAD_PARAMETER, BOTAN_FFI_ERROR_INSUFFICIENT_BUFFER_SPACE, BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_SUCCESS, BOTAN_FFI_VISIT, BOTAN_UNUSED, and Botan::copy_mem().

botan_privkey_x448_get_privkey()

int botan_privkey_x448_get_privkey	(	botan_privkey_t	key,
		uint8_t	output[56] )

Definition at line 1162 of file ffi_pkey_algs.cpp.

                                                                            {
   if(output == nullptr) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
#if defined(BOTAN_HAS_X448)
   return BOTAN_FFI_VISIT(key, [=](const auto& k) {
      if(auto x448 = dynamic_cast<const Botan::X448_PrivateKey*>(&k)) {
         const auto x448_key = x448->raw_private_key_bits();
         Botan::copy_mem(std::span{output, 56}, x448_key);
         return BOTAN_FFI_SUCCESS;
      } else {
         return BOTAN_FFI_ERROR_BAD_PARAMETER;
      }
   });
#else
   BOTAN_UNUSED(key, output);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References BOTAN_FFI_ERROR_BAD_PARAMETER, BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_SUCCESS, BOTAN_FFI_VISIT, BOTAN_UNUSED, and Botan::copy_mem().

botan_pubkey_algo_name()

int botan_pubkey_algo_name	(	botan_pubkey_t	key,
		char	out[],
		size_t *	out_len )

Definition at line 166 of file ffi_pkey.cpp.

                                                                            {
   return BOTAN_FFI_VISIT(key, [=](const auto& k) { return write_str_output(out, out_len, k.algo_name()); });
}

References BOTAN_FFI_VISIT, and Botan_FFI::write_str_output().

botan_pubkey_check_key()

int botan_pubkey_check_key	(	botan_pubkey_t	key,
		botan_rng_t	rng,
		uint32_t	flags )

Returns 0 if key is valid, negative if invalid key or some other error

Definition at line 170 of file ffi_pkey.cpp.

                                                                                {
   const bool strong = (flags & BOTAN_CHECK_KEY_EXPENSIVE_TESTS) != 0;
 
   return BOTAN_FFI_VISIT(key, [=](const auto& k) {
      return (k.check_key(safe_get(rng), strong) == true) ? 0 : BOTAN_FFI_ERROR_INVALID_INPUT;
   });
}

References BOTAN_CHECK_KEY_EXPENSIVE_TESTS, BOTAN_FFI_ERROR_INVALID_INPUT, BOTAN_FFI_VISIT, and Botan_FFI::safe_get().

botan_pubkey_destroy()

int botan_pubkey_destroy

(

botan_pubkey_t

key

)

Returns

0 if success, error if invalid object handle

Definition at line 148 of file ffi_pkey.cpp.

                                             {
   return BOTAN_FFI_CHECKED_DELETE(key);
}

References BOTAN_FFI_CHECKED_DELETE.

botan_pubkey_dsa_get_g()

int botan_pubkey_dsa_get_g	(	botan_mp_t	d,
		botan_pubkey_t	key )

Definition at line 431 of file ffi_pkey_algs.cpp.

                                                             {
   return botan_pubkey_get_field(g, key, "g");
}

References botan_pubkey_get_field().

botan_pubkey_dsa_get_p()

int botan_pubkey_dsa_get_p	(	botan_mp_t	p,
		botan_pubkey_t	key )

Definition at line 423 of file ffi_pkey_algs.cpp.

                                                             {
   return botan_pubkey_get_field(p, key, "p");
}

References botan_pubkey_get_field().

botan_pubkey_dsa_get_q()

int botan_pubkey_dsa_get_q	(	botan_mp_t	q,
		botan_pubkey_t	key )

Definition at line 427 of file ffi_pkey_algs.cpp.

                                                             {
   return botan_pubkey_get_field(q, key, "q");
}

References botan_pubkey_get_field().

botan_pubkey_dsa_get_y()

int botan_pubkey_dsa_get_y	(	botan_mp_t	y,
		botan_pubkey_t	key )

Definition at line 435 of file ffi_pkey_algs.cpp.

                                                             {
   return botan_pubkey_get_field(y, key, "y");
}

References botan_pubkey_get_field().

botan_pubkey_ecc_key_used_explicit_encoding()

int botan_pubkey_ecc_key_used_explicit_encoding

(

botan_pubkey_t

key

)

Definition at line 445 of file ffi_pkey_algs.cpp.

                                                                    {
#if defined(BOTAN_HAS_ECC_KEY)
   return ffi_guard_thunk(__func__, [=]() -> int {
      const Botan::Public_Key& pub_key = safe_get(key);
      const Botan::EC_PublicKey* ec_key = dynamic_cast<const Botan::EC_PublicKey*>(&pub_key);
 
      if(ec_key == nullptr) {
         return BOTAN_FFI_ERROR_BAD_PARAMETER;
      }
 
      return ec_key->domain().used_explicit_encoding() ? 1 : 0;
   });
#else
   BOTAN_UNUSED(key);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References BOTAN_FFI_ERROR_BAD_PARAMETER, BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_UNUSED, Botan::EC_PublicKey::domain(), Botan_FFI::ffi_guard_thunk(), Botan_FFI::safe_get(), and Botan::EC_Group::used_explicit_encoding().

botan_pubkey_ed25519_get_pubkey()

int botan_pubkey_ed25519_get_pubkey	(	botan_pubkey_t	key,
		uint8_t	pubkey[32] )

Definition at line 955 of file ffi_pkey_algs.cpp.

                                                                            {
   if(output == nullptr) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
#if defined(BOTAN_HAS_ED25519)
   return BOTAN_FFI_VISIT(key, [=](const auto& k) {
      if(auto ed = dynamic_cast<const Botan::Ed25519_PublicKey*>(&k)) {
         const std::vector<uint8_t>& ed_key = ed->get_public_key();
         if(ed_key.size() != 32) {
            return BOTAN_FFI_ERROR_INSUFFICIENT_BUFFER_SPACE;
         }
         Botan::copy_mem(output, ed_key.data(), ed_key.size());
         return BOTAN_FFI_SUCCESS;
      } else {
         return BOTAN_FFI_ERROR_BAD_PARAMETER;
      }
   });
#else
   BOTAN_UNUSED(key, output);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References BOTAN_FFI_ERROR_BAD_PARAMETER, BOTAN_FFI_ERROR_INSUFFICIENT_BUFFER_SPACE, BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_SUCCESS, BOTAN_FFI_VISIT, BOTAN_UNUSED, and Botan::copy_mem().

botan_pubkey_ed448_get_pubkey()

int botan_pubkey_ed448_get_pubkey	(	botan_pubkey_t	key,
		uint8_t	pubkey[57] )

Definition at line 1032 of file ffi_pkey_algs.cpp.

                                                                          {
   if(output == nullptr) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
#if defined(BOTAN_HAS_ED448)
   return BOTAN_FFI_VISIT(key, [=](const auto& k) {
      if(auto ed = dynamic_cast<const Botan::Ed448_PublicKey*>(&k)) {
         const auto ed_key = ed->public_key_bits();
         Botan::copy_mem(std::span(output, 57), ed_key);
         return BOTAN_FFI_SUCCESS;
      } else {
         return BOTAN_FFI_ERROR_BAD_PARAMETER;
      }
   });
#else
   BOTAN_UNUSED(key, output);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References BOTAN_FFI_ERROR_BAD_PARAMETER, BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_SUCCESS, BOTAN_FFI_VISIT, BOTAN_UNUSED, and Botan::copy_mem().

botan_pubkey_estimated_strength()

int botan_pubkey_estimated_strength	(	botan_pubkey_t	key,
		size_t *	estimate )

Definition at line 452 of file ffi_pkey.cpp.

                                                                          {
   if(estimate == nullptr) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
   return BOTAN_FFI_VISIT(key, [=](const auto& k) { *estimate = k.estimated_strength(); });
}

References BOTAN_FFI_ERROR_NULL_POINTER, and BOTAN_FFI_VISIT.

botan_pubkey_export()

int botan_pubkey_export	(	botan_pubkey_t	key,
		uint8_t	out[],
		size_t *	out_len,
		uint32_t	flags )

Definition at line 185 of file ffi_pkey.cpp.

                                                                                            {
   if(flags == BOTAN_PRIVKEY_EXPORT_FLAG_DER) {
      return copy_view_bin(out, out_len, botan_pubkey_view_der, key);
   } else if(flags == BOTAN_PRIVKEY_EXPORT_FLAG_PEM) {
      return copy_view_str(out, out_len, botan_pubkey_view_pem, key);
   } else if(flags == BOTAN_PRIVKEY_EXPORT_FLAG_RAW) {
      return copy_view_bin(out, out_len, botan_pubkey_view_raw, key);
   } else {
      return BOTAN_FFI_ERROR_BAD_FLAG;
   }
}

References BOTAN_FFI_ERROR_BAD_FLAG, BOTAN_PRIVKEY_EXPORT_FLAG_DER, BOTAN_PRIVKEY_EXPORT_FLAG_PEM, BOTAN_PRIVKEY_EXPORT_FLAG_RAW, botan_pubkey_view_der(), botan_pubkey_view_pem(), botan_pubkey_view_raw(), Botan_FFI::copy_view_bin(), and Botan_FFI::copy_view_str().

botan_pubkey_fingerprint()

int botan_pubkey_fingerprint	(	botan_pubkey_t	key,
		const char *	hash,
		uint8_t	out[],
		size_t *	out_len )

Definition at line 459 of file ffi_pkey.cpp.

                                                                                                      {
   if(hash_fn == nullptr) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
   return BOTAN_FFI_VISIT(key, [=](const auto& k) {
      auto h = Botan::HashFunction::create_or_throw(hash_fn);
      return write_vec_output(out, out_len, h->process(k.public_key_bits()));
   });
}

References BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_VISIT, Botan::HashFunction::create_or_throw(), and Botan_FFI::write_vec_output().

botan_pubkey_get_field()

int botan_pubkey_get_field	(	botan_mp_t	output,
		botan_pubkey_t	key,
		const char *	field_name )

Definition at line 206 of file ffi_pkey_algs.cpp.

                                                                                               {
   if(field_name_cstr == nullptr) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
 
   const std::string field_name(field_name_cstr);
 
   return BOTAN_FFI_VISIT(key, [=](const auto& k) { safe_get(output) = pubkey_get_field(k, field_name); });
}

References BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_VISIT, and Botan_FFI::safe_get().

Referenced by botan_pubkey_dsa_get_g(), botan_pubkey_dsa_get_p(), botan_pubkey_dsa_get_q(), botan_pubkey_dsa_get_y(), botan_pubkey_rsa_get_e(), and botan_pubkey_rsa_get_n().

botan_pubkey_load()

int botan_pubkey_load	(	botan_pubkey_t *	key,
		const uint8_t	bits[],
		size_t	len )

Definition at line 124 of file ffi_pkey.cpp.

                                                                                  {
   if(key == nullptr) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
 
   *key = nullptr;
 
   if(bits == nullptr && bits_len > 0) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
 
   return ffi_guard_thunk(__func__, [=]() -> int {
      Botan::DataSource_Memory src(bits, bits_len);
      std::unique_ptr<Botan::Public_Key> pubkey(Botan::X509::load_key(src));
 
      if(pubkey == nullptr) {
         return BOTAN_FFI_ERROR_UNKNOWN_ERROR;
      }
 
      ffi_new_object(key, std::move(pubkey));
      return BOTAN_FFI_SUCCESS;
   });
}

References BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_ERROR_UNKNOWN_ERROR, BOTAN_FFI_SUCCESS, Botan_FFI::ffi_guard_thunk(), Botan_FFI::ffi_new_object(), and Botan::X509::load_key().

botan_pubkey_load_classic_mceliece()

int botan_pubkey_load_classic_mceliece	(	botan_pubkey_t *	key,
		const uint8_t	pubkey[],
		size_t	key_len,
		const char *	cmce_mode )

Definition at line 1519 of file ffi_pkey_algs.cpp.

                                                              {
#if defined(BOTAN_HAS_CLASSICMCELIECE)
   if(Botan::any_null_pointers(key, pubkey, cmce_mode)) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
 
   *key = nullptr;
 
   return ffi_guard_thunk(__func__, [=]() -> int {
      const auto mode = Botan::Classic_McEliece_Parameter_Set::from_string(cmce_mode);
      auto cmce_key = std::make_unique<Botan::Classic_McEliece_PublicKey>(std::span{pubkey, key_len}, mode);
      return ffi_new_object(key, std::move(cmce_key));
   });
#else
   BOTAN_UNUSED(key, pubkey, key_len, cmce_mode);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References Botan::any_null_pointers(), BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_UNUSED, Botan_FFI::ffi_guard_thunk(), Botan_FFI::ffi_new_object(), and Botan::Classic_McEliece_Parameter_Set::from_string().

botan_pubkey_load_dsa()

int botan_pubkey_load_dsa	(	botan_pubkey_t *	key,
		botan_mp_t	p,
		botan_mp_t	q,
		botan_mp_t	g,
		botan_mp_t	y )

Definition at line 401 of file ffi_pkey_algs.cpp.

                                                                                                       {
#if defined(BOTAN_HAS_DSA)
   if(key == nullptr) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
   *key = nullptr;
 
   return ffi_guard_thunk(__func__, [=]() -> int {
      const Botan::DL_Group group(safe_get(p), safe_get(q), safe_get(g));
      auto dsa = std::make_unique<Botan::DSA_PublicKey>(group, safe_get(y));
      return ffi_new_object(key, std::move(dsa));
   });
#else
   BOTAN_UNUSED(key, p, q, g, y);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_UNUSED, Botan_FFI::ffi_guard_thunk(), Botan_FFI::ffi_new_object(), and Botan_FFI::safe_get().

botan_pubkey_load_ecdh()

int botan_pubkey_load_ecdh	(	botan_pubkey_t *	key,
		botan_mp_t	public_x,
		botan_mp_t	public_y,
		const char *	curve_name )

Definition at line 657 of file ffi_pkey_algs.cpp.

                                                   {
#if defined(BOTAN_HAS_ECDH)
   if(Botan::any_null_pointers(key, curve_name)) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
   *key = nullptr;
   return ffi_guard_thunk(__func__, [=]() -> int {
      std::unique_ptr<Botan::ECDH_PublicKey> p_key;
      const int rc = pubkey_load_ec(p_key, safe_get(public_x), safe_get(public_y), curve_name);
 
      if(rc == BOTAN_FFI_SUCCESS) {
         ffi_new_object(key, std::move(p_key));
      }
      return rc;
   });
#else
   BOTAN_UNUSED(key, public_x, public_y, curve_name);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References Botan::any_null_pointers(), BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_SUCCESS, BOTAN_UNUSED, Botan_FFI::ffi_guard_thunk(), Botan_FFI::ffi_new_object(), and Botan_FFI::safe_get().

botan_pubkey_load_ecdh_sec1()

int botan_pubkey_load_ecdh_sec1	(	botan_pubkey_t *	key,
		const uint8_t	sec1[],
		size_t	sec1_len,
		const char *	curve_name )

Definition at line 681 of file ffi_pkey_algs.cpp.

                                                                                                                    {
#if defined(BOTAN_HAS_ECDH)
   if(Botan::any_null_pointers(key, sec1, curve_name)) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
   *key = nullptr;
 
   return ffi_guard_thunk(__func__, [=]() -> int {
      std::unique_ptr<Botan::ECDH_PublicKey> p_key;
 
      const int rc = pubkey_load_ec_sec1(p_key, {sec1, sec1_len}, curve_name);
      if(rc == BOTAN_FFI_SUCCESS) {
         ffi_new_object(key, std::move(p_key));
      }
 
      return rc;
   });
#else
   BOTAN_UNUSED(key, sec1, sec1_len, curve_name);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References Botan::any_null_pointers(), BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_SUCCESS, BOTAN_UNUSED, Botan_FFI::ffi_guard_thunk(), and Botan_FFI::ffi_new_object().

botan_pubkey_load_ecdsa()

int botan_pubkey_load_ecdsa	(	botan_pubkey_t *	key,
		botan_mp_t	public_x,
		botan_mp_t	public_y,
		const char *	curve_name )

Definition at line 465 of file ffi_pkey_algs.cpp.

                                                    {
#if defined(BOTAN_HAS_ECDSA)
   if(Botan::any_null_pointers(key, curve_name)) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
   *key = nullptr;
 
   return ffi_guard_thunk(__func__, [=]() -> int {
      std::unique_ptr<Botan::ECDSA_PublicKey> p_key;
 
      const int rc = pubkey_load_ec(p_key, safe_get(public_x), safe_get(public_y), curve_name);
      if(rc == BOTAN_FFI_SUCCESS) {
         ffi_new_object(key, std::move(p_key));
      }
 
      return rc;
   });
#else
   BOTAN_UNUSED(key, public_x, public_y, curve_name);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References Botan::any_null_pointers(), BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_SUCCESS, BOTAN_UNUSED, Botan_FFI::ffi_guard_thunk(), Botan_FFI::ffi_new_object(), and Botan_FFI::safe_get().

botan_pubkey_load_ecdsa_sec1()

int botan_pubkey_load_ecdsa_sec1	(	botan_pubkey_t *	key,
		const uint8_t	sec1[],
		size_t	sec1_len,
		const char *	curve_name )

Definition at line 491 of file ffi_pkey_algs.cpp.

                                                                                                                     {
#if defined(BOTAN_HAS_ECDSA)
   if(Botan::any_null_pointers(key, sec1, curve_name)) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
   *key = nullptr;
 
   return ffi_guard_thunk(__func__, [=]() -> int {
      std::unique_ptr<Botan::ECDSA_PublicKey> p_key;
 
      const int rc = pubkey_load_ec_sec1(p_key, {sec1, sec1_len}, curve_name);
      if(rc == BOTAN_FFI_SUCCESS) {
         ffi_new_object(key, std::move(p_key));
      }
 
      return rc;
   });
#else
   BOTAN_UNUSED(key, sec1, sec1_len, curve_name);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References Botan::any_null_pointers(), BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_SUCCESS, BOTAN_UNUSED, Botan_FFI::ffi_guard_thunk(), and Botan_FFI::ffi_new_object().

botan_pubkey_load_ed25519()

int botan_pubkey_load_ed25519	(	botan_pubkey_t *	key,
		const uint8_t	pubkey[32] )

Definition at line 915 of file ffi_pkey_algs.cpp.

                                                                             {
#if defined(BOTAN_HAS_ED25519)
   if(key == nullptr) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
   *key = nullptr;
   return ffi_guard_thunk(__func__, [=]() -> int {
      const std::vector<uint8_t> pubkey_vec(pubkey, pubkey + 32);
      auto ed25519 = std::make_unique<Botan::Ed25519_PublicKey>(pubkey_vec);
      return ffi_new_object(key, std::move(ed25519));
   });
#else
   BOTAN_UNUSED(key, pubkey);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_UNUSED, Botan_FFI::ffi_guard_thunk(), and Botan_FFI::ffi_new_object().

botan_pubkey_load_ed448()

int botan_pubkey_load_ed448	(	botan_pubkey_t *	key,
		const uint8_t	pubkey[57] )

Definition at line 996 of file ffi_pkey_algs.cpp.

                                                                           {
#if defined(BOTAN_HAS_ED448)
   if(key == nullptr) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
   *key = nullptr;
   return ffi_guard_thunk(__func__, [=]() -> int {
      auto ed448 = std::make_unique<Botan::Ed448_PublicKey>(std::span(pubkey, 57));
      return ffi_new_object(key, std::move(ed448));
   });
#else
   BOTAN_UNUSED(key, pubkey);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_UNUSED, Botan_FFI::ffi_guard_thunk(), and Botan_FFI::ffi_new_object().

botan_pubkey_load_frodokem()

int botan_pubkey_load_frodokem	(	botan_pubkey_t *	key,
		const uint8_t	pubkey[],
		size_t	key_len,
		const char *	frodo_mode )

Definition at line 1474 of file ffi_pkey_algs.cpp.

                                                                                                                    {
#if defined(BOTAN_HAS_FRODOKEM)
   if(Botan::any_null_pointers(key, pubkey, frodo_mode)) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
 
   *key = nullptr;
 
   return ffi_guard_thunk(__func__, [=]() -> int {
      const auto mode = Botan::FrodoKEMMode(frodo_mode);
      auto frodo_key = std::make_unique<Botan::FrodoKEM_PublicKey>(std::span{pubkey, key_len}, mode);
      return ffi_new_object(key, std::move(frodo_key));
   });
#else
   BOTAN_UNUSED(key, pubkey, key_len, frodo_mode);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References Botan::any_null_pointers(), BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_UNUSED, Botan_FFI::ffi_guard_thunk(), and Botan_FFI::ffi_new_object().

botan_pubkey_load_kyber()

int botan_pubkey_load_kyber	(	botan_pubkey_t *	key,
		const uint8_t	pubkey[],
		size_t	key_len )

Definition at line 1238 of file ffi_pkey_algs.cpp.

                                                                                         {
#if defined(BOTAN_HAS_KYBER)
   if(Botan::any_null_pointers(key, pubkey)) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
   *key = nullptr;
 
   const auto mode = [](size_t len) -> std::optional<Botan::KyberMode> {
      if(len == 800) {
         return Botan::KyberMode::Kyber512_R3;
      } else if(len == 1184) {
         return Botan::KyberMode::Kyber768_R3;
      } else if(len == 1568) {
         return Botan::KyberMode::Kyber1024_R3;
      } else {
         return {};
      }
   }(key_len);
 
   if(mode.has_value()) {
      return ffi_guard_thunk(__func__, [=]() -> int {
         auto kyber = std::make_unique<Botan::Kyber_PublicKey>(std::span{pubkey, key_len}, *mode);
         return ffi_new_object(key, std::move(kyber));
      });
   } else {
      return BOTAN_FFI_ERROR_BAD_PARAMETER;
   }
#else
   BOTAN_UNUSED(key, pubkey, key_len);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References Botan::any_null_pointers(), BOTAN_FFI_ERROR_BAD_PARAMETER, BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_UNUSED, Botan_FFI::ffi_guard_thunk(), Botan_FFI::ffi_new_object(), Botan::KyberMode::Kyber1024_R3, Botan::KyberMode::Kyber512_R3, and Botan::KyberMode::Kyber768_R3.

botan_pubkey_load_ml_dsa()

int botan_pubkey_load_ml_dsa	(	botan_pubkey_t *	key,
		const uint8_t	pubkey[],
		size_t	key_len,
		const char *	mldsa_mode )

Definition at line 1378 of file ffi_pkey_algs.cpp.

                                                                                                                  {
#if defined(BOTAN_HAS_ML_DSA)
   if(Botan::any_null_pointers(key, pubkey, mldsa_mode)) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
 
   *key = nullptr;
 
   return ffi_guard_thunk(__func__, [=]() -> int {
      auto mode = Botan::ML_DSA_Mode(mldsa_mode);
      if(!mode.is_ml_dsa()) {
         return BOTAN_FFI_ERROR_BAD_PARAMETER;
      }
 
      auto mldsa_key = std::make_unique<Botan::ML_DSA_PublicKey>(std::span{pubkey, key_len}, mode);
      return ffi_new_object(key, std::move(mldsa_key));
   });
#else
   BOTAN_UNUSED(key, key_len, pubkey, mldsa_mode);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References Botan::any_null_pointers(), BOTAN_FFI_ERROR_BAD_PARAMETER, BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_UNUSED, Botan_FFI::ffi_guard_thunk(), and Botan_FFI::ffi_new_object().

botan_pubkey_load_ml_kem()

int botan_pubkey_load_ml_kem	(	botan_pubkey_t *	key,
		const uint8_t	pubkey[],
		size_t	key_len,
		const char *	mlkem_mode )

Definition at line 1328 of file ffi_pkey_algs.cpp.

                                                                                                                  {
#if defined(BOTAN_HAS_ML_KEM)
   if(Botan::any_null_pointers(key, pubkey, mlkem_mode)) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
 
   *key = nullptr;
 
   return ffi_guard_thunk(__func__, [=]() -> int {
      auto mode = Botan::ML_KEM_Mode(mlkem_mode);
      if(!mode.is_ml_kem()) {
         return BOTAN_FFI_ERROR_BAD_PARAMETER;
      }
 
      auto mlkem_key = std::make_unique<Botan::ML_KEM_PublicKey>(std::span{pubkey, key_len}, mode.mode());
      return ffi_new_object(key, std::move(mlkem_key));
   });
#else
   BOTAN_UNUSED(key, key_len, pubkey, mlkem_mode);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References Botan::any_null_pointers(), BOTAN_FFI_ERROR_BAD_PARAMETER, BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_UNUSED, Botan_FFI::ffi_guard_thunk(), and Botan_FFI::ffi_new_object().

botan_pubkey_load_rsa()

int botan_pubkey_load_rsa	(	botan_pubkey_t *	key,
		botan_mp_t	n,
		botan_mp_t	e )

Definition at line 273 of file ffi_pkey_algs.cpp.

                                                                           {
#if defined(BOTAN_HAS_RSA)
   if(key == nullptr) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
   *key = nullptr;
   return ffi_guard_thunk(__func__, [=]() -> int {
      auto rsa = std::make_unique<Botan::RSA_PublicKey>(safe_get(n), safe_get(e));
      return ffi_new_object(key, std::move(rsa));
   });
#else
   BOTAN_UNUSED(key, n, e);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_UNUSED, Botan_FFI::ffi_guard_thunk(), Botan_FFI::ffi_new_object(), and Botan_FFI::safe_get().

botan_pubkey_load_rsa_pkcs1()

int botan_pubkey_load_rsa_pkcs1	(	botan_pubkey_t *	key,
		const uint8_t	bits[],
		size_t	len )

Definition at line 289 of file ffi_pkey_algs.cpp.

                                                                                       {
#if defined(BOTAN_HAS_RSA)
   if(Botan::any_null_pointers(key, bits)) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
   *key = nullptr;
 
   return ffi_guard_thunk(__func__, [=]() -> int {
      const Botan::AlgorithmIdentifier alg_id("RSA", Botan::AlgorithmIdentifier::USE_NULL_PARAM);
      auto rsa = std::make_unique<Botan::RSA_PublicKey>(alg_id, std::span{bits, len});
      return ffi_new_object(key, std::move(rsa));
   });
#else
   BOTAN_UNUSED(key, bits, len);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References Botan::any_null_pointers(), BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_UNUSED, Botan_FFI::ffi_guard_thunk(), Botan_FFI::ffi_new_object(), and Botan::AlgorithmIdentifier::USE_NULL_PARAM.

botan_pubkey_load_slh_dsa()

int botan_pubkey_load_slh_dsa	(	botan_pubkey_t *	key,
		const uint8_t	pubkey[],
		size_t	key_len,
		const char *	slhdsa_mode )

Definition at line 1428 of file ffi_pkey_algs.cpp.

                                                                                                                    {
#if defined(BOTAN_HAS_SLH_DSA_WITH_SHA2) || defined(BOTAN_HAS_SLH_DSA_WITH_SHAKE)
   if(Botan::any_null_pointers(key, pubkey, slhdsa_mode)) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
 
   *key = nullptr;
 
   return ffi_guard_thunk(__func__, [=]() -> int {
      auto mode = Botan::SLH_DSA_Parameters::create(slhdsa_mode);
      if(!mode.is_slh_dsa()) {
         return BOTAN_FFI_ERROR_BAD_PARAMETER;
      }
 
      auto mldsa_key = std::make_unique<Botan::SLH_DSA_PublicKey>(std::span{pubkey, key_len}, mode);
      return ffi_new_object(key, std::move(mldsa_key));
   });
#else
   BOTAN_UNUSED(key, key_len, pubkey, slhdsa_mode);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References Botan::any_null_pointers(), BOTAN_FFI_ERROR_BAD_PARAMETER, BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_UNUSED, Botan_FFI::ffi_guard_thunk(), and Botan_FFI::ffi_new_object().

botan_pubkey_load_sm2()

int botan_pubkey_load_sm2	(	botan_pubkey_t *	key,
		botan_mp_t	public_x,
		botan_mp_t	public_y,
		const char *	curve_name )

Definition at line 759 of file ffi_pkey_algs.cpp.

                                                  {
#if defined(BOTAN_HAS_SM2)
   if(Botan::any_null_pointers(key, curve_name)) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
   *key = nullptr;
 
   return ffi_guard_thunk(__func__, [=]() -> int {
      std::unique_ptr<Botan::SM2_PublicKey> p_key;
      if(pubkey_load_ec(p_key, safe_get(public_x), safe_get(public_y), curve_name) == 0) {
         return ffi_new_object(key, std::move(p_key));
      } else {
         return BOTAN_FFI_ERROR_UNKNOWN_ERROR;
      }
   });
#else
   BOTAN_UNUSED(key, public_x, public_y, curve_name);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References Botan::any_null_pointers(), BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_ERROR_UNKNOWN_ERROR, BOTAN_UNUSED, Botan_FFI::ffi_guard_thunk(), Botan_FFI::ffi_new_object(), and Botan_FFI::safe_get().

Referenced by botan_pubkey_load_sm2_enc().

botan_pubkey_load_sm2_enc()

int botan_pubkey_load_sm2_enc	(	botan_pubkey_t *	key,
		botan_mp_t	public_x,
		botan_mp_t	public_y,
		const char *	curve_name )

Definition at line 828 of file ffi_pkey_algs.cpp.

                                                      {
   return botan_pubkey_load_sm2(key, public_x, public_y, curve_name);
}

References botan_pubkey_load_sm2().

botan_pubkey_load_sm2_sec1()

int botan_pubkey_load_sm2_sec1	(	botan_pubkey_t *	key,
		const uint8_t	sec1[],
		size_t	sec1_len,
		const char *	curve_name )

Definition at line 783 of file ffi_pkey_algs.cpp.

                                                                                                                   {
#if defined(BOTAN_HAS_SM2)
   if(Botan::any_null_pointers(key, sec1, curve_name)) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
   *key = nullptr;
 
   return ffi_guard_thunk(__func__, [=]() -> int {
      std::unique_ptr<Botan::SM2_PublicKey> p_key;
 
      const int rc = pubkey_load_ec_sec1(p_key, {sec1, sec1_len}, curve_name);
      if(rc == BOTAN_FFI_SUCCESS) {
         ffi_new_object(key, std::move(p_key));
      }
 
      return rc;
   });
#else
   BOTAN_UNUSED(key, sec1, sec1_len, curve_name);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References Botan::any_null_pointers(), BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_SUCCESS, BOTAN_UNUSED, Botan_FFI::ffi_guard_thunk(), and Botan_FFI::ffi_new_object().

botan_pubkey_load_x25519()

int botan_pubkey_load_x25519	(	botan_pubkey_t *	key,
		const uint8_t	pubkey[32] )

Definition at line 1070 of file ffi_pkey_algs.cpp.

                                                                            {
#if defined(BOTAN_HAS_X25519)
   if(key == nullptr) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
   *key = nullptr;
   return ffi_guard_thunk(__func__, [=]() -> int {
      auto x25519 = std::make_unique<Botan::X25519_PublicKey>(std::span{pubkey, 32});
      return ffi_new_object(key, std::move(x25519));
   });
#else
   BOTAN_UNUSED(key, pubkey);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_UNUSED, Botan_FFI::ffi_guard_thunk(), and Botan_FFI::ffi_new_object().

botan_pubkey_load_x448()

int botan_pubkey_load_x448	(	botan_pubkey_t *	key,
		const uint8_t	pubkey[56] )

Definition at line 1146 of file ffi_pkey_algs.cpp.

                                                                          {
#if defined(BOTAN_HAS_X448)
   if(key == nullptr) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
   *key = nullptr;
   return ffi_guard_thunk(__func__, [=]() -> int {
      auto x448 = std::make_unique<Botan::X448_PublicKey>(std::span{pubkey, 56});
      return ffi_new_object(key, std::move(x448));
   });
#else
   BOTAN_UNUSED(key, pubkey);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_UNUSED, Botan_FFI::ffi_guard_thunk(), and Botan_FFI::ffi_new_object().

botan_pubkey_oid()

int botan_pubkey_oid	(	botan_asn1_oid_t *	oid,
		botan_pubkey_t	key )

Definition at line 396 of file ffi_pkey.cpp.

                                                                {
   return BOTAN_FFI_VISIT(key, [=](const auto& k) {
      if(oid == nullptr) {
         return BOTAN_FFI_ERROR_NULL_POINTER;
      }
 
      auto oid_ptr = std::make_unique<Botan::OID>(k.object_identifier());
      ffi_new_object(oid, std::move(oid_ptr));
 
      return BOTAN_FFI_SUCCESS;
   });
}

References BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_SUCCESS, BOTAN_FFI_VISIT, and Botan_FFI::ffi_new_object().

botan_pubkey_rsa_get_e()

int botan_pubkey_rsa_get_e	(	botan_mp_t	e,
		botan_pubkey_t	rsa_key )

Definition at line 327 of file ffi_pkey_algs.cpp.

                                                             {
   return botan_pubkey_get_field(e, key, "e");
}

References botan_pubkey_get_field().

botan_pubkey_rsa_get_n()

int botan_pubkey_rsa_get_n	(	botan_mp_t	n,
		botan_pubkey_t	rsa_key )

Definition at line 331 of file ffi_pkey_algs.cpp.

                                                             {
   return botan_pubkey_get_field(n, key, "n");
}

References botan_pubkey_get_field().

botan_pubkey_sm2_compute_za()

int botan_pubkey_sm2_compute_za	(	uint8_t	out[],
		size_t *	out_len,
		const char *	ident,
		const char *	hash_algo,
		botan_pubkey_t	key )

Definition at line 726 of file ffi_pkey_algs.cpp.

                                                                                                       {
   if(Botan::any_null_pointers(out, out_len, ident, hash_algo, key)) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
 
#if defined(BOTAN_HAS_SM2)
   return ffi_guard_thunk(__func__, [=]() -> int {
      const Botan::Public_Key& pub_key = safe_get(key);
      const Botan::EC_PublicKey* ec_key = dynamic_cast<const Botan::EC_PublicKey*>(&pub_key);
 
      if(ec_key == nullptr) {
         return BOTAN_FFI_ERROR_BAD_PARAMETER;
      }
 
      if(ec_key->algo_name() != "SM2") {
         return BOTAN_FFI_ERROR_BAD_PARAMETER;
      }
 
      const std::string ident_str(ident);
      std::unique_ptr<Botan::HashFunction> hash = Botan::HashFunction::create_or_throw(hash_algo);
 
      const auto& pt = ec_key->_public_ec_point();
 
      const auto za = Botan::sm2_compute_za(*hash, ident_str, ec_key->domain(), pt);
 
      return write_vec_output(out, out_len, za);
   });
#else
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References Botan::EC_PublicKey::_public_ec_point(), Botan::Asymmetric_Key::algo_name(), Botan::any_null_pointers(), BOTAN_FFI_ERROR_BAD_PARAMETER, BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, Botan::HashFunction::create_or_throw(), Botan::EC_PublicKey::domain(), Botan_FFI::ffi_guard_thunk(), Botan_FFI::safe_get(), Botan::sm2_compute_za(), and Botan_FFI::write_vec_output().

botan_pubkey_view_der()

int botan_pubkey_view_der	(	botan_pubkey_t	key,
		botan_view_ctx	ctx,
		botan_view_bin_fn	view )

View the public key's DER encoding

Definition at line 197 of file ffi_pkey.cpp.

                                                                                          {
   return BOTAN_FFI_VISIT(
      key, [=](const auto& k) -> int { return invoke_view_callback(view, ctx, k.subject_public_key()); });
}

References BOTAN_FFI_VISIT, and Botan_FFI::invoke_view_callback().

Referenced by botan_pubkey_export().

botan_pubkey_view_ec_public_point()

int botan_pubkey_view_ec_public_point	(	botan_pubkey_t	key,
		botan_view_ctx	ctx,
		botan_view_bin_fn	view )

View the uncompressed public point associated with the key

Definition at line 1541 of file ffi_pkey_algs.cpp.

                                                                                                            {
#if defined(BOTAN_HAS_ECC_PUBLIC_KEY_CRYPTO)
   return BOTAN_FFI_VISIT(key, [=](const auto& k) -> int {
      if(auto ecc = dynamic_cast<const Botan::EC_PublicKey*>(&k)) {
         auto pt = ecc->_public_ec_point().serialize_uncompressed();
         return invoke_view_callback(view, ctx, pt);
      } else {
         return BOTAN_FFI_ERROR_BAD_PARAMETER;
      }
   });
#else
   BOTAN_UNUSED(key, view, ctx);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References BOTAN_FFI_ERROR_BAD_PARAMETER, BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_VISIT, BOTAN_UNUSED, and Botan_FFI::invoke_view_callback().

botan_pubkey_view_kyber_raw_key()

int botan_pubkey_view_kyber_raw_key	(	botan_pubkey_t	key,
		botan_view_ctx	ctx,
		botan_view_bin_fn	view )

Definition at line 1286 of file ffi_pkey_algs.cpp.

                                                                                                    {
#if defined(BOTAN_HAS_KYBER)
   return BOTAN_FFI_VISIT(key, [=](const auto& k) -> int {
      if(auto kyber = dynamic_cast<const Botan::Kyber_PublicKey*>(&k)) {
         return invoke_view_callback(view, ctx, kyber->public_key_bits());
      } else {
         return BOTAN_FFI_ERROR_BAD_PARAMETER;
      }
   });
#else
   BOTAN_UNUSED(key, ctx, view);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References BOTAN_FFI_ERROR_BAD_PARAMETER, BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_VISIT, BOTAN_UNUSED, and Botan_FFI::invoke_view_callback().

botan_pubkey_view_pem()

int botan_pubkey_view_pem	(	botan_pubkey_t	key,
		botan_view_ctx	ctx,
		botan_view_str_fn	view )

View the public key's PEM encoding

Definition at line 202 of file ffi_pkey.cpp.

                                                                                          {
   return BOTAN_FFI_VISIT(
      key, [=](const auto& k) -> int { return invoke_view_callback(view, ctx, Botan::X509::PEM_encode(k)); });
}

References BOTAN_FFI_VISIT, Botan_FFI::invoke_view_callback(), and Botan::X509::PEM_encode().

Referenced by botan_pubkey_export().

botan_pubkey_view_raw()

int botan_pubkey_view_raw	(	botan_pubkey_t	key,
		botan_view_ctx	ctx,
		botan_view_bin_fn	view )

View the public key's raw encoding

Definition at line 207 of file ffi_pkey.cpp.

                                                                                          {
   return BOTAN_FFI_VISIT(
      key, [=](const auto& k) -> int { return invoke_view_callback(view, ctx, k.raw_public_key_bits()); });
}

References BOTAN_FFI_VISIT, and Botan_FFI::invoke_view_callback().

Referenced by botan_pubkey_export().

botan_pubkey_x25519_get_pubkey()

int botan_pubkey_x25519_get_pubkey	(	botan_pubkey_t	key,
		uint8_t	pubkey[32] )

Definition at line 1109 of file ffi_pkey_algs.cpp.

                                                                           {
   if(output == nullptr) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
#if defined(BOTAN_HAS_X25519)
   return BOTAN_FFI_VISIT(key, [=](const auto& k) {
      if(auto x25519 = dynamic_cast<const Botan::X25519_PublicKey*>(&k)) {
         Botan::copy_mem(std::span{output, 32}, x25519->raw_public_key_bits());
         return BOTAN_FFI_SUCCESS;
      } else {
         return BOTAN_FFI_ERROR_BAD_PARAMETER;
      }
   });
#else
   BOTAN_UNUSED(key, output);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References BOTAN_FFI_ERROR_BAD_PARAMETER, BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_SUCCESS, BOTAN_FFI_VISIT, BOTAN_UNUSED, and Botan::copy_mem().

botan_pubkey_x448_get_pubkey()

int botan_pubkey_x448_get_pubkey	(	botan_pubkey_t	key,
		uint8_t	pubkey[56] )

Definition at line 1182 of file ffi_pkey_algs.cpp.

                                                                         {
   if(output == nullptr) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
#if defined(BOTAN_HAS_X448)
   return BOTAN_FFI_VISIT(key, [=](const auto& k) {
      if(auto x448 = dynamic_cast<const Botan::X448_PublicKey*>(&k)) {
         Botan::copy_mem(std::span{output, 56}, x448->raw_public_key_bits());
         return BOTAN_FFI_SUCCESS;
      } else {
         return BOTAN_FFI_ERROR_BAD_PARAMETER;
      }
   });
#else
   BOTAN_UNUSED(key, output);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References BOTAN_FFI_ERROR_BAD_PARAMETER, BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_SUCCESS, BOTAN_FFI_VISIT, BOTAN_UNUSED, and Botan::copy_mem().

botan_pwdhash()

int botan_pwdhash	(	const char *	algo,
		size_t	param1,
		size_t	param2,
		size_t	param3,
		uint8_t	out[],
		size_t	out_len,
		const char *	passphrase,
		size_t	passphrase_len,
		const uint8_t	salt[],
		size_t	salt_len )

Definition at line 54 of file ffi_kdf.cpp.

                                   {
   if(algo == nullptr || password == nullptr) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
   if(out_len > 0 && out == nullptr) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
   if(salt_len > 0 && salt == nullptr) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
 
   if(password_len == 0) {
      password_len = std::strlen(password);
   }
 
   return ffi_guard_thunk(__func__, [=]() -> int {
      auto pwdhash_fam = Botan::PasswordHashFamily::create(algo);
 
      if(!pwdhash_fam) {
         return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
      }
 
      auto pwdhash = pwdhash_fam->from_params(param1, param2, param3);
 
      pwdhash->derive_key(out, out_len, password, password_len, salt, salt_len);
 
      return BOTAN_FFI_SUCCESS;
   });
}

References BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_SUCCESS, Botan::PasswordHashFamily::create(), and Botan_FFI::ffi_guard_thunk().

Referenced by botan_pbkdf(), and botan_scrypt().

botan_pwdhash_timed()

int botan_pwdhash_timed	(	const char *	algo,
		uint32_t	msec,
		size_t *	param1,
		size_t *	param2,
		size_t *	param3,
		uint8_t	out[],
		size_t	out_len,
		const char *	passphrase,
		size_t	passphrase_len,
		const uint8_t	salt[],
		size_t	salt_len )

Definition at line 93 of file ffi_kdf.cpp.

                                         {
   if(algo == nullptr || password == nullptr) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
   if(out_len > 0 && out == nullptr) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
   if(salt_len > 0 && salt == nullptr) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
 
   if(password_len == 0) {
      password_len = std::strlen(password);
   }
 
   return ffi_guard_thunk(__func__, [=]() -> int {
      auto pwdhash_fam = Botan::PasswordHashFamily::create(algo);
 
      if(!pwdhash_fam) {
         return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
      }
 
      auto pwdhash = pwdhash_fam->tune_params(out_len, msec);
 
      if(param1 != nullptr) {
         *param1 = pwdhash->iterations();
      }
      if(param2 != nullptr) {
         *param2 = pwdhash->parallelism();
      }
      if(param3 != nullptr) {
         *param3 = pwdhash->memory_param();
      }
 
      pwdhash->derive_key(out, out_len, password, password_len, salt, salt_len);
 
      return BOTAN_FFI_SUCCESS;
   });
}

References BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_SUCCESS, Botan::PasswordHashFamily::create(), and Botan_FFI::ffi_guard_thunk().

Referenced by botan_pbkdf_timed().

botan_rng_add_entropy()

int botan_rng_add_entropy	(	botan_rng_t	rng,
		const uint8_t *	entropy,
		size_t	entropy_len )

Add some seed material to a random number generator

Parameters

Random Number Generators	rng object
Entropy Collection	the data to add
entropy_len	length of entropy buffer

Returns

0 on success, a negative value on failure

Definition at line 189 of file ffi_rng.cpp.

                                                                             {
   if(len > 0 && input == nullptr) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
   return BOTAN_FFI_VISIT(rng, [=](auto& r) { r.add_entropy(input, len); });
}

References BOTAN_FFI_ERROR_NULL_POINTER, and BOTAN_FFI_VISIT.

botan_rng_destroy()

int botan_rng_destroy

(

botan_rng_t

rng

)

Frees all resources of the random number generator object

Parameters

Random Number Generators

rng object

Returns

0 if success, error if invalid object handle

Definition at line 164 of file ffi_rng.cpp.

                                       {
   return BOTAN_FFI_CHECKED_DELETE(rng);
}

References BOTAN_FFI_CHECKED_DELETE.

botan_rng_generate_with_input()

int botan_rng_generate_with_input	(	botan_rng_t	rng,
		uint8_t *	out,
		size_t	out_len,
		const uint8_t *	addl_input,
		size_t	addl_len )

Generate random bytes from an RNG with additional input.

For a DRBG, the additional input is mixed in before generating. Many other RNG types (eg RDRAND or system RNG) will ignore the input.

Parameters

Random Number Generators	the RNG object
out	output buffer
out_len	number of bytes to generate
addl_input	additional input to mix in (may be NULL if addl_len is 0)
addl_len	length of additional input

Returns

0 on success, negative on failure

Definition at line 230 of file ffi_rng.cpp.

                                                                                              {
   if(out_len > 0 && out == nullptr) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
   if(addl_len > 0 && addl_input == nullptr) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
   return BOTAN_FFI_VISIT(rng, [=](auto& r) { r.randomize_with_input({out, out_len}, {addl_input, addl_len}); });
}

References BOTAN_FFI_ERROR_NULL_POINTER, and BOTAN_FFI_VISIT.

botan_rng_get()

int botan_rng_get	(	botan_rng_t	rng,
		uint8_t *	out,
		size_t	out_len )

Get random bytes from a random number generator

Parameters

Random Number Generators	rng object
out	output buffer of size out_len
out_len	number of requested bytes

Returns

0 on success, negative on failure

Definition at line 168 of file ffi_rng.cpp.

                                                                 {
   if(out_len > 0 && out == nullptr) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
   return BOTAN_FFI_VISIT(rng, [=](auto& r) { r.randomize(out, out_len); });
}

References BOTAN_FFI_ERROR_NULL_POINTER, and BOTAN_FFI_VISIT.

botan_rng_init()

int botan_rng_init	(	botan_rng_t *	rng,
		const char *	rng_type )

Initialize a random number generator object

Parameters

Random Number Generators	rng object
rng_type	type of the rng, possible values: "system": system RNG "esdm-full": ESDM RNG (fully seeded) "esdm-pr": ESDM RNG (w. prediction resistance) "user": userspace RNG "user-threadsafe": userspace RNG, with internal locking "rdrand": directly read RDRAND Set rng_type to null to let the library choose some default.

Definition at line 38 of file ffi_rng.cpp.

                                                               {
   return ffi_guard_thunk(__func__, [=]() -> int {
      if(rng_out == nullptr) {
         return BOTAN_FFI_ERROR_NULL_POINTER;
      }
 
      const std::string rng_type_s(rng_type != nullptr ? rng_type : "system");
 
      std::unique_ptr<Botan::RandomNumberGenerator> rng;
 
      if(rng_type_s == "system") {
         rng = std::make_unique<Botan::System_RNG>();
      } else if(rng_type_s == "user" || rng_type_s == "user-threadsafe") {
         rng = std::make_unique<Botan::AutoSeeded_RNG>();
      } else if(rng_type_s == "null") {
         rng = std::make_unique<Botan::Null_RNG>();
      }
#if defined(BOTAN_HAS_PROCESSOR_RNG)
      else if((rng_type_s == "rdrand" || rng_type_s == "hwrng") && Botan::Processor_RNG::available()) {
         rng = std::make_unique<Botan::Processor_RNG>();
      }
#endif
#if defined(BOTAN_HAS_JITTER_RNG)
      else if(rng_type_s == "jitter") {
         rng = std::make_unique<Botan::Jitter_RNG>();
      }
#endif
#if defined(BOTAN_HAS_ESDM_RNG)
      else if(rng_type_s == "esdm-full") {
         rng = std::make_unique<Botan::ESDM_RNG>(false);
      } else if(rng_type_s == "esdm-pr") {
         rng = std::make_unique<Botan::ESDM_RNG>(true);
      }
#endif
 
      if(!rng) {
         return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
      }
 
      return ffi_new_object(rng_out, std::move(rng));
   });
}

References Botan::Processor_RNG::available(), BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, Botan_FFI::ffi_guard_thunk(), and Botan_FFI::ffi_new_object().

botan_rng_init_custom()

int botan_rng_init_custom	(	botan_rng_t *	rng_out,
		const char *	rng_name,
		void *	context,
		int(*	get_cb )(void *context, uint8_t *out, size_t out_len),
		int(*	add_entropy_cb )(void *context, const uint8_t input[], size_t length),
		void(*	destroy_cb )(void *context) )

Initialize a custom random number generator from a set of callback functions

Parameters

rng_out	rng object to create
rng_name	name of the rng
context	An application-specific context passed to the callback functions
get_cb	Callback for getting random bytes from the rng, return 0 for success
add_entropy_cb	Callback for adding entropy to the rng, return 0 for success, may be NULL
destroy_cb	Callback called when rng is destroyed, may be NULL

Definition at line 81 of file ffi_rng.cpp.

                                                             {
   return ffi_guard_thunk(__func__, [=]() -> int {
      if(rng_out == nullptr) {
         return BOTAN_FFI_ERROR_NULL_POINTER;
      }
 
      if(rng_name == nullptr) {
         return BOTAN_FFI_ERROR_NULL_POINTER;
      }
 
      if(get_cb == nullptr) {
         return BOTAN_FFI_ERROR_NULL_POINTER;
      }
 
      class Custom_RNG final : public Botan::RandomNumberGenerator {
         public:
            Custom_RNG(std::string_view name,
                       void* context,
                       int (*get_cb)(void* context, uint8_t* out, size_t out_len),
                       int (*add_entropy_cb)(void* context, const uint8_t input[], size_t length),
                       void (*destroy_cb)(void* context)) :
                  m_name(name),
                  m_context(context),
                  m_get_cb(get_cb),
                  m_add_entropy_cb(add_entropy_cb),
                  m_destroy_cb(destroy_cb) {}
 
            ~Custom_RNG() override {
               if(m_destroy_cb) {
                  m_destroy_cb(m_context);
               }
            }
 
            Custom_RNG(const Custom_RNG& other) = delete;
            Custom_RNG(Custom_RNG&& other) = delete;
            Custom_RNG& operator=(const Custom_RNG& other) = delete;
            Custom_RNG& operator=(Custom_RNG&& other) = delete;
 
         protected:
            void fill_bytes_with_input(std::span<uint8_t> output, std::span<const uint8_t> input) override {
               if(accepts_input() && !input.empty()) {
                  const int rc = m_add_entropy_cb(m_context, input.data(), input.size());
                  if(rc != 0) {
                     throw Botan::Invalid_State("Failed to add entropy via C callback, rc=" + std::to_string(rc));
                  }
               }
 
               if(!output.empty()) {
                  const int rc = m_get_cb(m_context, output.data(), output.size());
                  if(rc != 0) {
                     throw Botan::Invalid_State("Failed to get random from C callback, rc=" + std::to_string(rc));
                  }
               }
            }
 
         public:
            bool accepts_input() const override { return m_add_entropy_cb != nullptr; }
 
            std::string name() const override { return m_name; }
 
            void clear() override {}
 
            bool is_seeded() const override { return true; }
 
         private:
            std::string m_name;
            void* m_context;
            std::function<int(void* context, uint8_t* out, size_t out_len)> m_get_cb;
            std::function<int(void* context, const uint8_t input[], size_t length)> m_add_entropy_cb;
            std::function<void(void* context)> m_destroy_cb;
      };
 
      auto rng = std::make_unique<Custom_RNG>(rng_name, context, get_cb, add_entropy_cb, destroy_cb);
 
      return ffi_new_object(rng_out, std::move(rng));
   });
}

References BOTAN_FFI_ERROR_NULL_POINTER, Botan_FFI::ffi_guard_thunk(), and Botan_FFI::ffi_new_object().

botan_rng_init_drbg()

int botan_rng_init_drbg	(	botan_rng_t *	rng_out,
		const char *	drbg_name,
		const uint8_t *	seed,
		size_t	seed_len )

Create and seed a DRBG

Parameters

rng_out	the new DRBG object
drbg_name	the name of the DRBG (e.g. "HMAC_DRBG(SHA-256)")
SEED	the seed material (entropy || nonce || personalization_string)
seed_len	length of seed in bytes

Returns

0 on success, negative on failure

Definition at line 200 of file ffi_rng.cpp.

                                                                                                           {
   return ffi_guard_thunk(__func__, [=]() -> int {
      if(rng_out == nullptr || drbg_name == nullptr) {
         return BOTAN_FFI_ERROR_NULL_POINTER;
      }
      if(seed_len > 0 && seed == nullptr) {
         return BOTAN_FFI_ERROR_NULL_POINTER;
      }
 
      std::unique_ptr<Botan::Stateful_RNG> drbg;
      const std::string name(drbg_name);
 
#if defined(BOTAN_HAS_HMAC_DRBG)
      if(name.starts_with("HMAC_DRBG(") && name.ends_with(")") && name.size() > 12) {
         const std::string hash = name.substr(10, name.size() - 11);
         drbg = std::make_unique<Botan::HMAC_DRBG>(hash);
      }
#endif
 
      if(!drbg) {
         return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
      }
 
      drbg->initialize_with(std::span(seed, seed_len));
      // Upcast to RandomNumberGenerator for the FFI object
      std::unique_ptr<Botan::RandomNumberGenerator> rng(std::move(drbg));
      return ffi_new_object(rng_out, std::move(rng));
   });
}

References BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, Botan_FFI::ffi_guard_thunk(), and Botan_FFI::ffi_new_object().

botan_rng_reseed()

int botan_rng_reseed	(	botan_rng_t	rng,
		size_t	bits )

Reseed a random number generator Uses the System_RNG as a seed generator.

Parameters

Random Number Generators	rng object
bits	number of bits to reseed with

Returns

0 on success, a negative value on failure

Definition at line 185 of file ffi_rng.cpp.

                                                   {
   return BOTAN_FFI_VISIT(rng, [=](auto& r) { r.reseed_from_rng(Botan::system_rng(), bits); });
}

References BOTAN_FFI_VISIT, and Botan::system_rng().

botan_rng_reseed_from_rng()

int botan_rng_reseed_from_rng	(	botan_rng_t	rng,
		botan_rng_t	source_rng,
		size_t	bits )

Reseed a random number generator

Parameters

Random Number Generators	rng object
source_rng	the rng that will be read from
bits	number of bits to reseed with

Returns

0 on success, a negative value on failure

Definition at line 196 of file ffi_rng.cpp.

                                                                                    {
   return BOTAN_FFI_VISIT(rng, [=](auto& r) { r.reseed_from_rng(safe_get(source_rng), bits); });
}

References BOTAN_FFI_VISIT, and Botan_FFI::safe_get().

botan_same_mem()

int botan_same_mem	(	const uint8_t *	x,
		const uint8_t *	y,
		size_t	len )

Deprecated equivalent to botan_constant_time_compare

Definition at line 327 of file ffi.cpp.

                                                                   {
   return botan_constant_time_compare(x, y, len);
}

References botan_constant_time_compare().

botan_scrub_mem()

int botan_scrub_mem	(	void *	mem,
		size_t	bytes )

Clear out memory using a system specific approach to bypass elision by the compiler (currently using RtlSecureZeroMemory or tricks with volatile pointers).

Definition at line 331 of file ffi.cpp.

                                             {
   if(bytes > 0 && mem == nullptr) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
   Botan::secure_scrub_memory(mem, bytes);
   return BOTAN_FFI_SUCCESS;
}

References BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_SUCCESS, and Botan::secure_scrub_memory().

botan_scrypt()

int botan_scrypt	(	uint8_t	out[],
		size_t	out_len,
		const char *	passphrase,
		const uint8_t	salt[],
		size_t	salt_len,
		size_t	N,
		size_t	r,
		size_t	p )

Derive a key using scrypt Deprecated; use botan_pwdhash("Scrypt", N, r, p, out, out_len, password, 0, salt, salt_len);

Definition at line 166 of file ffi_kdf.cpp.

                           {
   return botan_pwdhash("Scrypt", N, r, p, out, out_len, password, 0, salt, salt_len);
}

References botan_pwdhash().

botan_srp6_client_agree()

int botan_srp6_client_agree	(	const char *	username,
		const char *	password,
		const char *	group_id,
		const char *	hash_id,
		const uint8_t	salt[],
		size_t	salt_len,
		const uint8_t	B[],
		size_t	B_len,
		botan_rng_t	rng_obj,
		uint8_t	A[],
		size_t *	A_len,
		uint8_t	K[],
		size_t *	K_len )

SRP6a Client side

Parameters

username	the username we are attempting login for
password	the password we are attempting to use
group_id	specifies the shared SRP group
Hash Function Identification	specifies a secure hash function
salt	is the salt value sent by the server
salt_len	the length of salt
B	is the server's public value
B_len	is the server's public value length
rng_obj	is a random number generator object
A	out buffer to store the SRP-6 A value
A_len	SRP-6 A verifier value length
K	out buffer to store the symmetric value
K_len	symmetric key length

Returns

0 on success, negative on failure

Definition at line 153 of file ffi_srp6.cpp.

                                           {
#if defined(BOTAN_HAS_SRP6)
   return ffi_guard_thunk(__func__, [=]() -> int {
      if(any_null_pointers(identity, password, salt, group_id, hash_id, b, rng_obj)) {
         return BOTAN_FFI_ERROR_NULL_POINTER;
      }
      try {
         const std::vector<uint8_t> saltv(salt, salt + salt_len);
         Botan::RandomNumberGenerator& rng = safe_get(rng_obj);
         auto b_bn = Botan::BigInt::from_bytes({b, b_len});
         const auto group = Botan::DL_Group::from_name(group_id);
         const size_t a_bits = group.exponent_bits();
         auto [A_bn, K_sk] = Botan::srp6_client_agree(identity, password, group, hash_id, saltv, b_bn, a_bits, rng);
         auto ret_a = write_vec_output(A, A_len, A_bn.serialize(group.p_bytes()));
         auto ret_k = write_vec_output(K, K_len, K_sk.bits_of());
         if(ret_a != BOTAN_FFI_SUCCESS) {
            return ret_a;
         }
         if(ret_k != BOTAN_FFI_SUCCESS) {
            return ret_k;
         }
         return BOTAN_FFI_SUCCESS;
      } catch(Botan::Lookup_Error&) {
         return BOTAN_FFI_ERROR_BAD_PARAMETER;
      }
   });
#else
   BOTAN_UNUSED(identity, password, group_id, hash_id, rng_obj);
   BOTAN_UNUSED(salt, salt_len, b, b_len, A, A_len, K, K_len);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References Botan_FFI::any_null_pointers(), BOTAN_FFI_ERROR_BAD_PARAMETER, BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_SUCCESS, BOTAN_UNUSED, Botan_FFI::ffi_guard_thunk(), Botan::BigInt::from_bytes(), Botan::DL_Group::from_name(), Botan_FFI::safe_get(), Botan::srp6_client_agree(), and Botan_FFI::write_vec_output().

Referenced by botan_srp6_server_session_step1().

botan_srp6_generate_verifier()

int botan_srp6_generate_verifier	(	const char *	identifier,
		const char *	password,
		const uint8_t	salt[],
		size_t	salt_len,
		const char *	group_id,
		const char *	hash_id,
		uint8_t	verifier[],
		size_t *	verifier_len )

Generate a new SRP-6 verifier

Parameters

identifier	a username or other client identifier
password	the secret used to authenticate user
salt	a randomly chosen value, at least 128 bits long
salt_len	the length of salt
group_id	specifies the shared SRP group
Hash Function Identification	specifies a secure hash function
verifier	out buffer to store the SRP-6 verifier value
verifier_len	SRP-6 verifier value length

Returns

0 on success, negative on failure

Definition at line 123 of file ffi_srp6.cpp.

                                                       {
#if defined(BOTAN_HAS_SRP6)
   return ffi_guard_thunk(__func__, [=]() -> int {
      if(any_null_pointers(username, password, salt, group_id, hash_id)) {
         return BOTAN_FFI_ERROR_NULL_POINTER;
      }
      try {
         const std::vector<uint8_t> salt_vec(salt, salt + salt_len);
         const auto group = Botan::DL_Group::from_name(group_id);
         const size_t p_bytes = group.p_bytes();
         auto verifier_bn = Botan::srp6_generate_verifier(username, password, salt_vec, group, hash_id);
         return write_vec_output(verifier, verifier_len, verifier_bn.serialize(p_bytes));
      } catch(Botan::Lookup_Error&) {
         return BOTAN_FFI_ERROR_BAD_PARAMETER;
      }
   });
#else
   BOTAN_UNUSED(username, password, group_id, hash_id);
   BOTAN_UNUSED(salt, salt_len, verifier, verifier_len);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References Botan_FFI::any_null_pointers(), BOTAN_FFI_ERROR_BAD_PARAMETER, BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_UNUSED, Botan_FFI::ffi_guard_thunk(), Botan::DL_Group::from_name(), Botan::srp6_generate_verifier(), and Botan_FFI::write_vec_output().

Referenced by botan_srp6_server_session_step1().

botan_srp6_group_size()

int botan_srp6_group_size	(	const char *	group_id,
		size_t *	group_p_bytes )

Return the size, in bytes, of the prime associated with group_id

Definition at line 49 of file ffi_srp6.cpp.

                                                                       {
#if defined(BOTAN_HAS_SRP6)
   if(any_null_pointers(group_id, group_p_bytes)) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
 
   return ffi_guard_thunk(__func__, [=]() -> int {
      const auto group = Botan::DL_Group::from_name(group_id);
      *group_p_bytes = group.p_bytes();
      return BOTAN_FFI_SUCCESS;
   });
#else
   BOTAN_UNUSED(group_id, group_p_bytes);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References Botan_FFI::any_null_pointers(), BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_SUCCESS, BOTAN_UNUSED, Botan_FFI::ffi_guard_thunk(), and Botan::DL_Group::from_name().

Referenced by botan_srp6_server_session_step1().

botan_srp6_server_session_destroy()

int botan_srp6_server_session_destroy

(

botan_srp6_server_session_t

srp6

)

Frees all resources of the SRP-6 server session object

Parameters

SRP-6a

SRP-6 server session object

Returns

0 if success, error if invalid object handle

Definition at line 45 of file ffi_srp6.cpp.

                                                                        {
   return BOTAN_FFI_CHECKED_DELETE(srp6);
}

References BOTAN_FFI_CHECKED_DELETE.

botan_srp6_server_session_init()

int botan_srp6_server_session_init

(

botan_srp6_server_session_t *

srp6

)

Initialize an SRP-6 server session object

Parameters

SRP-6a

SRP-6 server session object

Definition at line 32 of file ffi_srp6.cpp.

                                                                      {
#if defined(BOTAN_HAS_SRP6)
   if(srp6 == nullptr) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
   return ffi_guard_thunk(
      __func__, [=]() -> int { return ffi_new_object(srp6, std::make_unique<Botan::SRP6_Server_Session>()); });
#else
   BOTAN_UNUSED(srp6);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_UNUSED, Botan_FFI::ffi_guard_thunk(), and Botan_FFI::ffi_new_object().

botan_srp6_server_session_step1()

int botan_srp6_server_session_step1	(	botan_srp6_server_session_t	srp6,
		const uint8_t	verifier[],
		size_t	verifier_len,
		const char *	group_id,
		const char *	hash_id,
		botan_rng_t	rng_obj,
		uint8_t	B_pub[],
		size_t *	B_pub_len )

SRP-6 Server side step 1

Parameters

SRP-6a	SRP-6 server session object
verifier	the verification value saved from client registration
verifier_len	SRP-6 verifier value length
group_id	the SRP group id
Hash Function Identification	the SRP hash in use
rng_obj	a random number generator object
B_pub	out buffer to store the SRP-6 B value
B_pub_len	SRP-6 B value length

Returns

0 on success, negative on failure

References BOTAN_FFI_EXPORT, botan_srp6_client_agree(), botan_srp6_generate_verifier(), botan_srp6_group_size(), botan_srp6_server_session_step1(), botan_srp6_server_session_step2(), botan_zfec_decode(), and botan_zfec_encode().

Referenced by botan_srp6_server_session_step1().

botan_srp6_server_session_step2()

int botan_srp6_server_session_step2	(	botan_srp6_server_session_t	srp6,
		const uint8_t	A[],
		size_t	A_len,
		uint8_t	key[],
		size_t *	key_len )

SRP-6 Server side step 2

Parameters

SRP-6a	SRP-6 server session object
A	the client's value
A_len	the client's value length
key	out buffer to store the symmetric key value
key_len	symmetric key length

Returns

0 on success, negative on failure

Definition at line 102 of file ffi_srp6.cpp.

                                                                                                      {
#if defined(BOTAN_HAS_SRP6)
   return BOTAN_FFI_VISIT(srp6, [=](auto& s) -> int {
      if(!a) {
         return BOTAN_FFI_ERROR_NULL_POINTER;
      }
      try {
         const Botan::BigInt a_bn = Botan::BigInt::from_bytes({a, a_len});
         auto key_sk = s.step2(a_bn);
         return write_vec_output(key, key_len, key_sk.bits_of());
      } catch(Botan::Decoding_Error&) {
         return BOTAN_FFI_ERROR_BAD_PARAMETER;
      }
   });
#else
   BOTAN_UNUSED(srp6, a, a_len, key, key_len);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References BOTAN_FFI_ERROR_BAD_PARAMETER, BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_VISIT, BOTAN_UNUSED, Botan::BigInt::from_bytes(), and Botan_FFI::write_vec_output().

Referenced by botan_srp6_server_session_step1().

botan_system_rng_get()

int botan_system_rng_get	(	uint8_t *	out,
		size_t	out_len )

Get random bytes from system random number generator

Parameters

out	output buffer of size out_len
out_len	number of requested bytes

Returns

0 on success, negative on failure

Definition at line 175 of file ffi_rng.cpp.

                                                       {
   if(out_len > 0 && out == nullptr) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
   return ffi_guard_thunk(__func__, [=]() -> int {
      Botan::system_rng().randomize(out, out_len);
      return BOTAN_FFI_SUCCESS;
   });
}

References BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_SUCCESS, Botan_FFI::ffi_guard_thunk(), Botan::RandomNumberGenerator::randomize(), and Botan::system_rng().

botan_totp_check()

int botan_totp_check	(	botan_totp_t	totp,
		uint32_t	totp_code,
		uint64_t	timestamp,
		size_t	acceptable_clock_drift )

Verify a TOTP code

Parameters

totp	the TOTP object
totp_code	the presented OTP
timestamp	the current local timestamp
acceptable_clock_drift	specifies the acceptable amount of clock drift (in terms of time steps) between the two hosts.

Definition at line 68 of file ffi_totp.cpp.

                                                                                                               {
#if defined(BOTAN_HAS_TOTP)
   return BOTAN_FFI_VISIT(totp, [=](auto& t) {
      const bool ok = t.verify_totp(totp_code, timestamp, acceptable_clock_drift);
      return (ok ? BOTAN_FFI_SUCCESS : BOTAN_FFI_INVALID_VERIFIER);
   });
 
#else
   BOTAN_UNUSED(totp, totp_code, timestamp, acceptable_clock_drift);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_INVALID_VERIFIER, BOTAN_FFI_SUCCESS, BOTAN_FFI_VISIT, and BOTAN_UNUSED.

botan_totp_destroy()

int botan_totp_destroy

(

botan_totp_t

totp

)

Destroy a TOTP instance

Returns

0 if success, error if invalid object handle

Definition at line 45 of file ffi_totp.cpp.

                                          {
#if defined(BOTAN_HAS_TOTP)
   return BOTAN_FFI_CHECKED_DELETE(totp);
#else
   BOTAN_UNUSED(totp);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References BOTAN_FFI_CHECKED_DELETE, BOTAN_FFI_ERROR_NOT_IMPLEMENTED, and BOTAN_UNUSED.

botan_totp_generate()

int botan_totp_generate	(	botan_totp_t	totp,
		uint32_t *	totp_code,
		uint64_t	timestamp )

Generate a TOTP code for the provided timestamp

Parameters

totp	the TOTP object
totp_code	the OTP code will be written here
timestamp	the current local timestamp

Definition at line 54 of file ffi_totp.cpp.

                                                                                    {
#if defined(BOTAN_HAS_TOTP)
   if(totp == nullptr || totp_code == nullptr) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
 
   return BOTAN_FFI_VISIT(totp, [=](auto& t) { *totp_code = t.generate_totp(timestamp); });
 
#else
   BOTAN_UNUSED(totp, totp_code, timestamp);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_VISIT, and BOTAN_UNUSED.

botan_totp_init()

int botan_totp_init	(	botan_totp_t *	totp,
		const uint8_t	key[],
		size_t	key_len,
		const char *	hash_algo,
		size_t	digits,
		size_t	time_step )

Initialize a TOTP instance

Definition at line 26 of file ffi_totp.cpp.

                                                                                                                    {
   if(totp == nullptr || key == nullptr || hash_algo == nullptr) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
 
   *totp = nullptr;
 
#if defined(BOTAN_HAS_TOTP)
   return ffi_guard_thunk(__func__, [=]() -> int {
      auto otp = std::make_unique<Botan::TOTP>(key, key_len, hash_algo, digits, time_step);
      return ffi_new_object(totp, std::move(otp));
   });
#else
   BOTAN_UNUSED(totp, key, key_len, hash_algo, digits, time_step);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_UNUSED, Botan_FFI::ffi_guard_thunk(), and Botan_FFI::ffi_new_object().

botan_tpm2_crypto_backend_state_destroy()

int botan_tpm2_crypto_backend_state_destroy

(

botan_tpm2_crypto_backend_state_t

cbs

)

Frees all resources of a TPM2 Crypto Callback State Note that this does not attempt to de-register the crypto backend, it just frees the resource pointed to by cbs. Use the ESAPI function Esys_SetCryptoCallbacks(ctx, nullptr) to deregister manually.

Parameters

cbs	TPM2 Crypto Callback State

Returns

0 on success

Definition at line 203 of file ffi_tpm2.cpp.

                                                                                   {
#if defined(BOTAN_HAS_TPM2_CRYPTO_BACKEND)
   return BOTAN_FFI_CHECKED_DELETE(cbs);
#else
   BOTAN_UNUSED(cbs);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References BOTAN_FFI_CHECKED_DELETE, BOTAN_FFI_ERROR_NOT_IMPLEMENTED, and BOTAN_UNUSED.

botan_tpm2_ctx_destroy()

int botan_tpm2_ctx_destroy

(

botan_tpm2_ctx_t

ctx

)

Frees all resources of a TPM2 context

Parameters

ctx	TPM2 context

Returns

0 on success

Definition at line 172 of file ffi_tpm2.cpp.

                                                 {
#if defined(BOTAN_HAS_TPM2)
   return BOTAN_FFI_CHECKED_DELETE(ctx);
#else
   BOTAN_UNUSED(ctx);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References BOTAN_FFI_CHECKED_DELETE, BOTAN_FFI_ERROR_NOT_IMPLEMENTED, and BOTAN_UNUSED.

botan_tpm2_ctx_enable_crypto_backend()

int botan_tpm2_ctx_enable_crypto_backend	(	botan_tpm2_ctx_t	ctx,
		botan_rng_t	rng )

Enable Botan's TSS2 crypto backend that replaces the cryptographic functions required for the communication with the TPM with implementations provided by Botan instead of using TSS' defaults OpenSSL or mbedTLS. Note that the provided rng should not be dependent on the TPM and the caller must ensure that it remains usable for the lifetime of the ctx.

Parameters

ctx	TPM2 context
Random Number Generators	random number generator to be used by the crypto backend

Definition at line 150 of file ffi_tpm2.cpp.

                                                                                {
#if defined(BOTAN_HAS_TPM2)
   return BOTAN_FFI_VISIT(ctx, [=](botan_tpm2_ctx_wrapper& ctx_wrapper) -> int {
      Botan::RandomNumberGenerator& rng_ref = safe_get(rng);
 
      // The lifetime of the RNG used for the crypto backend should be managed
      // by the TPM2::Context. Here, we just need to trust the user that they
      // keep the passed-in RNG instance intact for the lifetime of the context.
      ctx_wrapper.ctx->use_botan_crypto_backend(std::shared_ptr<Botan::RandomNumberGenerator>(&rng_ref, [](auto*) {}));
      return BOTAN_FFI_SUCCESS;
   });
#else
   BOTAN_UNUSED(ctx, rng);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_SUCCESS, BOTAN_FFI_VISIT, BOTAN_UNUSED, and Botan_FFI::safe_get().

botan_tpm2_ctx_from_esys()

int botan_tpm2_ctx_from_esys	(	botan_tpm2_ctx_t *	ctx_out,
		struct ESYS_CONTEXT *	esys_ctx )

Wrap an existing ESYS_CONTEXT for use in Botan. Note that destroying the created botan_tpm2_ctx_t won't finalize esys_ctx

Parameters

ctx_out	output TPM2 context
esys_ctx	ESYS_CONTEXT to wrap

Returns

0 on success

Definition at line 133 of file ffi_tpm2.cpp.

                                                                                {
#if defined(BOTAN_HAS_TPM2)
   return ffi_guard_thunk(__func__, [=]() -> int {
      if(ctx_out == nullptr || esys_ctx == nullptr) {
         return BOTAN_FFI_ERROR_NULL_POINTER;
      }
 
      auto ctx = std::make_unique<botan_tpm2_ctx_wrapper>();
      ctx->ctx = Botan::TPM2::Context::create(esys_ctx);
      return ffi_new_object(ctx_out, std::move(ctx));
   });
#else
   BOTAN_UNUSED(ctx_out, esys_ctx);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_UNUSED, Botan::TPM2::Context::create(), Botan_FFI::ffi_guard_thunk(), and Botan_FFI::ffi_new_object().

botan_tpm2_ctx_init()

int botan_tpm2_ctx_init	(	botan_tpm2_ctx_t *	ctx_out,
		const char *	tcti_nameconf )

Initialize a TPM2 context

Parameters

ctx_out	output TPM2 context
tcti_nameconf	TCTI config (may be nullptr)

Returns

0 on success

Definition at line 75 of file ffi_tpm2.cpp.

                                                                              {
#if defined(BOTAN_HAS_TPM2)
   return ffi_guard_thunk(__func__, [=]() -> int {
      if(ctx_out == nullptr) {
         return BOTAN_FFI_ERROR_NULL_POINTER;
      }
      auto ctx = std::make_unique<botan_tpm2_ctx_wrapper>();
 
      auto tcti = [=]() -> std::optional<std::string> {
         if(tcti_nameconf == nullptr) {
            return {};
         } else {
            return std::string(tcti_nameconf);
         }
      }();
 
      ctx->ctx = Botan::TPM2::Context::create(std::move(tcti));
      return ffi_new_object(ctx_out, std::move(ctx));
   });
#else
   BOTAN_UNUSED(ctx_out, tcti_nameconf);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_UNUSED, Botan::TPM2::Context::create(), Botan_FFI::ffi_guard_thunk(), and Botan_FFI::ffi_new_object().

botan_tpm2_ctx_init_ex()

int botan_tpm2_ctx_init_ex	(	botan_tpm2_ctx_t *	ctx_out,
		const char *	tcti_name,
		const char *	tcti_conf )

Initialize a TPM2 context

Parameters

ctx_out	output TPM2 context
tcti_name	TCTI name (may be nullptr)
tcti_conf	TCTI config (may be nullptr)

Returns

0 on success

Definition at line 100 of file ffi_tpm2.cpp.

                                                                                                    {
#if defined(BOTAN_HAS_TPM2)
   return ffi_guard_thunk(__func__, [=]() -> int {
      if(ctx_out == nullptr) {
         return BOTAN_FFI_ERROR_NULL_POINTER;
      }
      auto ctx = std::make_unique<botan_tpm2_ctx_wrapper>();
 
      auto tcti_name_str = [=]() -> std::optional<std::string> {
         if(tcti_name == nullptr) {
            return {};
         } else {
            return std::string(tcti_name);
         }
      }();
 
      auto tcti_conf_str = [=]() -> std::optional<std::string> {
         if(tcti_conf == nullptr) {
            return {};
         } else {
            return std::string(tcti_conf);
         }
      }();
 
      ctx->ctx = Botan::TPM2::Context::create(std::move(tcti_name_str), std::move(tcti_conf_str));
      return ffi_new_object(ctx_out, std::move(ctx));
   });
#else
   BOTAN_UNUSED(ctx_out, tcti_name, tcti_conf);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_UNUSED, Botan::TPM2::Context::create(), Botan_FFI::ffi_guard_thunk(), and Botan_FFI::ffi_new_object().

botan_tpm2_enable_crypto_backend()

int botan_tpm2_enable_crypto_backend	(	botan_tpm2_crypto_backend_state_t *	cbs_out,
		struct ESYS_CONTEXT *	esys_ctx,
		botan_rng_t	rng )

Use this if you just need Botan's crypto backend but do not want to wrap any other ESYS functionality using Botan's TPM2 wrapper. A Crypto Backend State is created that the user needs to keep alive for as long as the crypto backend is used and needs to be destroyed after. Note that the provided rng should not be dependent on the TPM and the caller must ensure that it remains usable for the lifetime of the esys_ctx.

Parameters

cbs_out	To be created Crypto Backend State
esys_ctx	TPM2 context
Random Number Generators	random number generator to be used by the crypto backend

Definition at line 181 of file ffi_tpm2.cpp.

                                                      {
#if defined(BOTAN_HAS_TPM2_CRYPTO_BACKEND)
   return ffi_guard_thunk(__func__, [=]() -> int {
      if(cbs_out == nullptr || esys_ctx == nullptr) {
         return BOTAN_FFI_ERROR_NULL_POINTER;
      }
 
      Botan::RandomNumberGenerator& rng_ref = safe_get(rng);
 
      // Here, we just need to trust the user that they keep the passed-in RNG
      // instance intact for the lifetime of the context.
      const std::shared_ptr<Botan::RandomNumberGenerator> rng_ptr(&rng_ref, [](auto*) {});
      return ffi_new_object(cbs_out, Botan::TPM2::use_botan_crypto_backend(esys_ctx, rng_ptr));
   });
#else
   BOTAN_UNUSED(cbs_out, esys_ctx, rng);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_UNUSED, Botan_FFI::ffi_guard_thunk(), Botan_FFI::ffi_new_object(), Botan_FFI::safe_get(), and Botan::TPM2::use_botan_crypto_backend().

botan_tpm2_rng_init()

int botan_tpm2_rng_init	(	botan_rng_t *	rng_out,
		botan_tpm2_ctx_t	ctx,
		botan_tpm2_session_t	s1,
		botan_tpm2_session_t	s2,
		botan_tpm2_session_t	s3 )

Initialize a random number generator object via TPM2

Parameters

rng_out	rng object to create
ctx	TPM2 context
s1	the first session to use (optional, may be nullptr)
s2	the second session to use (optional, may be nullptr)
s3	the third session to use (optional, may be nullptr)

Definition at line 212 of file ffi_tpm2.cpp.

                                                 {
#if defined(BOTAN_HAS_TPM2)
   return BOTAN_FFI_VISIT(ctx, [=](botan_tpm2_ctx_wrapper& ctx_wrapper) -> int {
      if(rng_out == nullptr) {
         return BOTAN_FFI_ERROR_NULL_POINTER;
      }
 
      return ffi_new_object(
         rng_out, std::make_unique<Botan::TPM2::RandomNumberGenerator>(ctx_wrapper.ctx, sessions(s1, s2, s3)));
   });
#else
   BOTAN_UNUSED(rng_out, ctx, s1, s2, s3);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_VISIT, BOTAN_UNUSED, and Botan_FFI::ffi_new_object().

botan_tpm2_session_destroy()

int botan_tpm2_session_destroy

(

botan_tpm2_session_t

session

)

Create an unauthenticated session for use with TPM2

Parameters

session

the session object to destroy

Definition at line 249 of file ffi_tpm2.cpp.

                                                             {
#if defined(BOTAN_HAS_TPM2)
   return BOTAN_FFI_CHECKED_DELETE(session);
#else
   BOTAN_UNUSED(session);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References BOTAN_FFI_CHECKED_DELETE, BOTAN_FFI_ERROR_NOT_IMPLEMENTED, and BOTAN_UNUSED.

botan_tpm2_supports_crypto_backend()

int botan_tpm2_supports_crypto_backend

(

void

)

Checks if Botan's TSS2 crypto backend can be used in this build

Returns

1 if the crypto backend can be enabled

Definition at line 67 of file ffi_tpm2.cpp.

                                         {
#if defined(BOTAN_HAS_TPM2)
   return Botan::TPM2::Context::supports_botan_crypto_backend() ? 1 : 0;
#else
   return 0;
#endif
}

References Botan::TPM2::Context::supports_botan_crypto_backend().

botan_tpm2_unauthenticated_session_init()

int botan_tpm2_unauthenticated_session_init	(	botan_tpm2_session_t *	session_out,
		botan_tpm2_ctx_t	ctx )

Create an unauthenticated session for use with TPM2

Parameters

session_out	the session object to create
ctx	TPM2 context

Definition at line 232 of file ffi_tpm2.cpp.

                                                                                                     {
#if defined(BOTAN_HAS_TPM2)
   return BOTAN_FFI_VISIT(ctx, [=](botan_tpm2_ctx_wrapper& ctx_wrapper) -> int {
      if(session_out == nullptr) {
         return BOTAN_FFI_ERROR_NULL_POINTER;
      }
 
      auto session = std::make_unique<botan_tpm2_session_wrapper>();
      session->session = Botan::TPM2::Session::unauthenticated_session(ctx_wrapper.ctx);
      return ffi_new_object(session_out, std::move(session));
   });
#else
   BOTAN_UNUSED(session_out, ctx);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_VISIT, BOTAN_UNUSED, Botan_FFI::ffi_new_object(), and Botan::TPM2::Session::unauthenticated_session().

botan_version_datestamp()

uint32_t botan_version_datestamp

(

void

)

Return the date this version was released as an integer.

Returns 0 if the library was not built from an official release

Definition at line 314 of file ffi.cpp.

                                   {
   return Botan::version_datestamp();
}

References Botan::version_datestamp().

botan_version_major()

uint32_t botan_version_major

(

void

)

Return the major version of the library

Definition at line 302 of file ffi.cpp.

                               {
   return Botan::version_major();
}

References Botan::version_major().

botan_version_minor()

uint32_t botan_version_minor

(

void

)

Return the minor version of the library

Definition at line 306 of file ffi.cpp.

                               {
   return Botan::version_minor();
}

References Botan::version_minor().

botan_version_patch()

uint32_t botan_version_patch

(

void

)

Return the patch version of the library

Definition at line 310 of file ffi.cpp.

                               {
   return Botan::version_patch();
}

References Botan::version_patch().

botan_version_string()

const char * botan_version_string

(

void

)

Return a free-form version string, e.g., 2.0.0

Definition at line 298 of file ffi.cpp.

                                   {
   return Botan::version_cstr();
}

References Botan::version_cstr().

botan_x509_cert_allowed_extended_usage_oid()

int botan_x509_cert_allowed_extended_usage_oid	(	botan_x509_cert_t	cert,
		botan_asn1_oid_t	oid )

Check if the certificate allows the specified extended usage OID. See RFC 5280 Section 4.2.1.12 for OIDs to query for this. If no extended key usage extension is found in the certificate, this always returns "not success".

This is similar to botan_x509_cert_allowed_extended_usage_str but takes an OID object instead of a string describing the OID.

Definition at line 598 of file ffi_cert.cpp.

                                                                                             {
#if defined(BOTAN_HAS_X509_CERTIFICATES)
   return BOTAN_FFI_VISIT(cert, [=](const auto& c) -> int { return c.has_ex_constraint(safe_get(oid)) ? 1 : 0; });
#else
   BOTAN_UNUSED(cert, oid);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_VISIT, BOTAN_UNUSED, and Botan_FFI::safe_get().

botan_x509_cert_allowed_extended_usage_str()

int botan_x509_cert_allowed_extended_usage_str	(	botan_x509_cert_t	cert,
		const char *	oid )

Check if the certificate allows the specified extended usage OID. See RFC 5280 Section 4.2.1.12 for OIDs to query for this. If no extended key usage extension is found in the certificate, this always returns "not success".

Typical OIDs to check for:

• "PKIX.ServerAuth"
• "PKIX.ClientAuth"
• "PKIX.CodeSigning"
• "PKIX.OCSPSigning"

The oid parameter can be either a canonical OID string or identifiers as indicated in the examples above.

Definition at line 583 of file ffi_cert.cpp.

                                                                                        {
#if defined(BOTAN_HAS_X509_CERTIFICATES)
   return BOTAN_FFI_VISIT(cert, [=](const auto& c) -> int {
      if(Botan::any_null_pointers(oid)) {
         return BOTAN_FFI_ERROR_NULL_POINTER;
      }
 
      return c.has_ex_constraint(oid) ? 1 : 0;
   });
#else
   BOTAN_UNUSED(cert, oid);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References Botan::any_null_pointers(), BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_VISIT, and BOTAN_UNUSED.

botan_x509_cert_allowed_usage()

int botan_x509_cert_allowed_usage	(	botan_x509_cert_t	cert,
		unsigned int	key_usage )

Definition at line 568 of file ffi_cert.cpp.

                                                                                  {
#if defined(BOTAN_HAS_X509_CERTIFICATES)
   return BOTAN_FFI_VISIT(cert, [=](const auto& c) -> int {
      const Botan::Key_Constraints k = static_cast<Botan::Key_Constraints>(key_usage);
      if(c.allowed_usage(k)) {
         return BOTAN_FFI_SUCCESS;
      }
      return 1;
   });
#else
   BOTAN_UNUSED(cert, key_usage);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_SUCCESS, BOTAN_FFI_VISIT, and BOTAN_UNUSED.

botan_x509_cert_destroy()

int botan_x509_cert_destroy

(

botan_x509_cert_t

cert

)

Returns

0 if success, error if invalid object handle

Definition at line 607 of file ffi_cert.cpp.

                                                    {
#if defined(BOTAN_HAS_X509_CERTIFICATES)
   return BOTAN_FFI_CHECKED_DELETE(cert);
#else
   BOTAN_UNUSED(cert);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References BOTAN_FFI_CHECKED_DELETE, BOTAN_FFI_ERROR_NOT_IMPLEMENTED, and BOTAN_UNUSED.

botan_x509_cert_dup()

int botan_x509_cert_dup	(	botan_x509_cert_t *	new_cert,
		botan_x509_cert_t	cert )

Definition at line 194 of file ffi_cert.cpp.

                                                                             {
   if(cert_obj == nullptr) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
 
#if defined(BOTAN_HAS_X509_CERTIFICATES) && defined(BOTAN_TARGET_OS_HAS_FILESYSTEM)
 
   return ffi_guard_thunk(__func__, [=]() -> int {
      auto c = std::make_unique<Botan::X509_Certificate>(safe_get(cert));
      return ffi_new_object(cert_obj, std::move(c));
   });
 
#else
   BOTAN_UNUSED(cert);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_UNUSED, Botan_FFI::ffi_guard_thunk(), Botan_FFI::ffi_new_object(), and Botan_FFI::safe_get().

botan_x509_cert_excluded_name_constraints()

int botan_x509_cert_excluded_name_constraints	(	botan_x509_cert_t	cert,
		size_t	index,
		botan_x509_general_name_t *	constraint )

Extracts "excluded" name constraints from a given cert one-by-one. Returns BOTAN_FFI_ERROR_OUT_OF_RANGE if the given index is larger than the available number of "excluded" name constraints.

Definition at line 847 of file ffi_cert.cpp.

                                                                                     {
#if defined(BOTAN_HAS_X509_CERTIFICATES)
   return BOTAN_FFI_VISIT(cert, [=](const Botan::X509_Certificate& c) {
      if(Botan::any_null_pointers(constraint)) {
         return BOTAN_FFI_ERROR_NULL_POINTER;
      }
 
      const auto& constraints = c.name_constraints().excluded();
      if(index >= constraints.size()) {
         return BOTAN_FFI_ERROR_OUT_OF_RANGE;
      }
 
      return ffi_new_object(constraint, std::make_unique<Botan::GeneralName>(constraints[index].base()));
   });
#else
   BOTAN_UNUSED(cert, index, constraint);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References Botan::any_null_pointers(), BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_ERROR_OUT_OF_RANGE, BOTAN_FFI_VISIT, BOTAN_UNUSED, Botan::NameConstraints::excluded(), Botan_FFI::ffi_new_object(), and Botan::X509_Certificate::name_constraints().

botan_x509_cert_excluded_name_constraints_count()

int botan_x509_cert_excluded_name_constraints_count	(	botan_x509_cert_t	cert,
		size_t *	count )

Definition at line 869 of file ffi_cert.cpp.

                                                                                           {
#if defined(BOTAN_HAS_X509_CERTIFICATES)
   if(Botan::any_null_pointers(count)) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
 
   return BOTAN_FFI_VISIT(cert, [=](const auto& c) { *count = c.name_constraints().excluded().size(); });
#else
   BOTAN_UNUSED(cert, count);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References Botan::any_null_pointers(), BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_VISIT, and BOTAN_UNUSED.

botan_x509_cert_get_authority_key_id()

int botan_x509_cert_get_authority_key_id	(	botan_x509_cert_t	cert,
		uint8_t	out[],
		size_t *	out_len )

Definition at line 701 of file ffi_cert.cpp.

                                                                                                 {
#if defined(BOTAN_HAS_X509_CERTIFICATES)
   return BOTAN_FFI_VISIT(cert, [=](const auto& c) { return write_vec_output(out, out_len, c.authority_key_id()); });
#else
   BOTAN_UNUSED(cert, out, out_len);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_VISIT, BOTAN_UNUSED, and Botan_FFI::write_vec_output().

botan_x509_cert_get_fingerprint()

int botan_x509_cert_get_fingerprint	(	botan_x509_cert_t	cert,
		const char *	hash,
		uint8_t	out[],
		size_t *	out_len )

Definition at line 685 of file ffi_cert.cpp.

                                                                                                              {
   if(hash == nullptr) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
#if defined(BOTAN_HAS_X509_CERTIFICATES)
   // TODO(Botan4) change the type of out and remove this cast
 
   return BOTAN_FFI_VISIT(cert, [=](const auto& c) {
      return write_str_output(reinterpret_cast<char*>(out), out_len, c.fingerprint(hash));
   });
#else
   BOTAN_UNUSED(cert, hash, out, out_len);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_VISIT, BOTAN_UNUSED, and Botan_FFI::write_str_output().

botan_x509_cert_get_issuer_dn()

int botan_x509_cert_get_issuer_dn	(	botan_x509_cert_t	cert,
		const char *	key,
		size_t	index,
		uint8_t	out[],
		size_t *	out_len )

Enumerates the names of the given key in the issuer DN. If index is out of bounds, BOTAN_FFI_ERROR_BAD_PARAMETER is returned.

TODO(Botan4) use BOTAN_FFI_ERROR_OUT_OF_RANGE instead of BAD_PARAMETER TODO(Botan4) this should use char for the out param

Definition at line 481 of file ffi_cert.cpp.

                                                                                          {
   if(key == nullptr) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
#if defined(BOTAN_HAS_X509_CERTIFICATES)
   return BOTAN_FFI_VISIT(cert, [=](const auto& c) -> int {
      auto issuer_info = c.issuer_info(key);
      if(index < issuer_info.size()) {
         // TODO(Botan4) change the type of out and remove this cast
         return write_str_output(reinterpret_cast<char*>(out), out_len, c.issuer_info(key).at(index));
      } else {
         return BOTAN_FFI_ERROR_BAD_PARAMETER;  // TODO(Botan4): use BOTAN_FFI_ERROR_OUT_OF_RANGE
      }
   });
#else
   BOTAN_UNUSED(cert, key, index, out, out_len);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References BOTAN_FFI_ERROR_BAD_PARAMETER, BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_VISIT, BOTAN_UNUSED, and Botan_FFI::write_str_output().

botan_x509_cert_get_issuer_dn_count()

int botan_x509_cert_get_issuer_dn_count	(	botan_x509_cert_t	cert,
		const char *	key,
		size_t *	count )

Definition at line 502 of file ffi_cert.cpp.

                                                                                                {
#if defined(BOTAN_HAS_X509_CERTIFICATES)
   return BOTAN_FFI_VISIT(cert, [=](const auto& c) -> int {
      if(Botan::any_null_pointers(count)) {
         return BOTAN_FFI_ERROR_NULL_POINTER;
      }
 
      *count = c.issuer_info(key).size();
      return BOTAN_FFI_SUCCESS;
   });
#else
   BOTAN_UNUSED(cert, key, count);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References Botan::any_null_pointers(), BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_SUCCESS, BOTAN_FFI_VISIT, and BOTAN_UNUSED.

botan_x509_cert_get_path_length_constraint()

int botan_x509_cert_get_path_length_constraint	(	botan_x509_cert_t	cert,
		size_t *	path_limit )

Retrieves the path length constraint from the certificate. If no such constraint is present, BOTAN_FFI_ERROR_NO_VALUE is returned.

Definition at line 443 of file ffi_cert.cpp.

                                                                                           {
#if defined(BOTAN_HAS_X509_CERTIFICATES)
   return BOTAN_FFI_VISIT(cert, [=](const auto& c) -> int {
      if(Botan::any_null_pointers(path_limit)) {
         return BOTAN_FFI_ERROR_NULL_POINTER;
      }
 
      if(const auto path_len = c.path_length_constraint()) {
         *path_limit = path_len.value();
         return BOTAN_FFI_SUCCESS;
      } else {
         return BOTAN_FFI_ERROR_NO_VALUE;
      }
   });
#else
   BOTAN_UNUSED(cert, path_limit);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References Botan::any_null_pointers(), BOTAN_FFI_ERROR_NO_VALUE, BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_SUCCESS, BOTAN_FFI_VISIT, and BOTAN_UNUSED.

botan_x509_cert_get_public_key()

int botan_x509_cert_get_public_key	(	botan_x509_cert_t	cert,
		botan_pubkey_t *	key )

Definition at line 463 of file ffi_cert.cpp.

                                                                                {
   if(key == nullptr) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
 
   *key = nullptr;
 
#if defined(BOTAN_HAS_X509_CERTIFICATES)
   return ffi_guard_thunk(__func__, [=]() -> int {
      auto public_key = safe_get(cert).subject_public_key();
      return ffi_new_object(key, std::move(public_key));
   });
#else
   BOTAN_UNUSED(cert);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_UNUSED, Botan_FFI::ffi_guard_thunk(), Botan_FFI::ffi_new_object(), and Botan_FFI::safe_get().

botan_x509_cert_get_public_key_bits()

int botan_x509_cert_get_public_key_bits	(	botan_x509_cert_t	cert,
		uint8_t	out[],
		size_t *	out_len )

Definition at line 719 of file ffi_cert.cpp.

                                                                                                {
   return copy_view_bin(out, out_len, botan_x509_cert_view_public_key_bits, cert);
}

References botan_x509_cert_view_public_key_bits(), and Botan_FFI::copy_view_bin().

botan_x509_cert_get_serial_number()

int botan_x509_cert_get_serial_number	(	botan_x509_cert_t	cert,
		uint8_t	out[],
		size_t *	out_len )

Definition at line 660 of file ffi_cert.cpp.

                                                                                              {
#if defined(BOTAN_HAS_X509_CERTIFICATES)
   return BOTAN_FFI_VISIT(cert, [=](const auto& c) { return write_vec_output(out, out_len, c.serial_number()); });
#else
   BOTAN_UNUSED(cert, out, out_len);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_VISIT, BOTAN_UNUSED, and Botan_FFI::write_vec_output().

botan_x509_cert_get_subject_dn()

int botan_x509_cert_get_subject_dn	(	botan_x509_cert_t	cert,
		const char *	key,
		size_t	index,
		uint8_t	out[],
		size_t *	out_len )

Enumerates the names of the given key in the subject DN. If index is out of bounds, BOTAN_FFI_ERROR_BAD_PARAMETER is returned.

TODO(Botan4) use BOTAN_FFI_ERROR_OUT_OF_RANGE instead of BAD_PARAMETER TODO(Botan4) this should use char for the out param

Definition at line 518 of file ffi_cert.cpp.

                                                                                          {
   if(key == nullptr) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
#if defined(BOTAN_HAS_X509_CERTIFICATES)
   return BOTAN_FFI_VISIT(cert, [=](const auto& c) -> int {
      auto subject_info = c.subject_info(key);
      if(index < subject_info.size()) {
         // TODO(Botan4) change the type of out and remove this cast
         return write_str_output(reinterpret_cast<char*>(out), out_len, c.subject_info(key).at(index));
      } else {
         return BOTAN_FFI_ERROR_BAD_PARAMETER;  // TODO(Botan4): use BOTAN_FFI_ERROR_OUT_OF_RANGE
      }
   });
#else
   BOTAN_UNUSED(cert, key, index, out, out_len);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References BOTAN_FFI_ERROR_BAD_PARAMETER, BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_VISIT, BOTAN_UNUSED, and Botan_FFI::write_str_output().

botan_x509_cert_get_subject_dn_count()

int botan_x509_cert_get_subject_dn_count	(	botan_x509_cert_t	cert,
		const char *	key,
		size_t *	count )

Definition at line 539 of file ffi_cert.cpp.

                                                                                                 {
#if defined(BOTAN_HAS_X509_CERTIFICATES)
   return BOTAN_FFI_VISIT(cert, [=](const auto& c) -> int {
      if(Botan::any_null_pointers(count)) {
         return BOTAN_FFI_ERROR_NULL_POINTER;
      }
 
      *count = c.subject_info(key).size();
      return BOTAN_FFI_SUCCESS;
   });
#else
   BOTAN_UNUSED(cert, key, count);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References Botan::any_null_pointers(), BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_SUCCESS, BOTAN_FFI_VISIT, and BOTAN_UNUSED.

botan_x509_cert_get_subject_key_id()

int botan_x509_cert_get_subject_key_id	(	botan_x509_cert_t	cert,
		uint8_t	out[],
		size_t *	out_len )

Definition at line 710 of file ffi_cert.cpp.

                                                                                               {
#if defined(BOTAN_HAS_X509_CERTIFICATES)
   return BOTAN_FFI_VISIT(cert, [=](const auto& c) { return write_vec_output(out, out_len, c.subject_key_id()); });
#else
   BOTAN_UNUSED(cert, out, out_len);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_VISIT, BOTAN_UNUSED, and Botan_FFI::write_vec_output().

botan_x509_cert_get_time_expires()

int botan_x509_cert_get_time_expires	(	botan_x509_cert_t	cert,
		char	out[],
		size_t *	out_len )

Definition at line 626 of file ffi_cert.cpp.

                                                                                          {
#if defined(BOTAN_HAS_X509_CERTIFICATES)
   return BOTAN_FFI_VISIT(cert,
                          [=](const auto& c) { return write_str_output(out, out_len, c.not_after().to_string()); });
#else
   BOTAN_UNUSED(cert, out, out_len);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_VISIT, BOTAN_UNUSED, and Botan_FFI::write_str_output().

botan_x509_cert_get_time_starts()

int botan_x509_cert_get_time_starts	(	botan_x509_cert_t	cert,
		char	out[],
		size_t *	out_len )

Definition at line 616 of file ffi_cert.cpp.

                                                                                         {
#if defined(BOTAN_HAS_X509_CERTIFICATES)
   return BOTAN_FFI_VISIT(cert,
                          [=](const auto& c) { return write_str_output(out, out_len, c.not_before().to_string()); });
#else
   BOTAN_UNUSED(cert, out, out_len);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_VISIT, BOTAN_UNUSED, and Botan_FFI::write_str_output().

botan_x509_cert_hostname_match()

int botan_x509_cert_hostname_match	(	botan_x509_cert_t	cert,
		const char *	hostname )

Check if the certificate matches the specified hostname via alternative name or CN match. RFC 5280 wildcards also supported.

Definition at line 960 of file ffi_cert.cpp.

                                                                                 {
   if(hostname == nullptr) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
 
#if defined(BOTAN_HAS_X509_CERTIFICATES)
   return BOTAN_FFI_VISIT(cert, [=](const auto& c) { return c.matches_dns_name(hostname) ? 0 : -1; });
#else
   BOTAN_UNUSED(cert);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_VISIT, and BOTAN_UNUSED.

botan_x509_cert_is_ca()

int botan_x509_cert_is_ca

(

botan_x509_cert_t

cert

)

Returns 1 iff the cert is a CA certificate

Definition at line 434 of file ffi_cert.cpp.

                                                  {
#if defined(BOTAN_HAS_X509_CERTIFICATES)
   return BOTAN_FFI_VISIT(cert, [=](const auto& c) { return c.is_CA_cert() ? 1 : 0; });
#else
   BOTAN_UNUSED(cert);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_VISIT, and BOTAN_UNUSED.

botan_x509_cert_issuer_alternative_names()

int botan_x509_cert_issuer_alternative_names	(	botan_x509_cert_t	cert,
		size_t	index,
		botan_x509_general_name_t *	alt_name )

Provides access to all "issuer alternative names", where each entry is returned as a botan_x509_general_name_t. If the given index is not within range of the available entries, BOTAN_FFI_ERROR_OUT_OF_RANGE is returned. If cert does not contain an IssuerAlternativeNames extension, BOTAN_FFI_ERROR_NO_VALUE is returned.

Definition at line 921 of file ffi_cert.cpp.

                                                                                  {
#if defined(BOTAN_HAS_X509_CERTIFICATES)
   return BOTAN_FFI_VISIT(cert, [=](const Botan::X509_Certificate& c) {
      if(Botan::any_null_pointers(alt_name)) {
         return BOTAN_FFI_ERROR_NULL_POINTER;
      }
 
      if(!c.v3_extensions().extension_set(Botan::OID::from_string("X509v3.IssuerAlternativeName"))) {
         return BOTAN_FFI_ERROR_NO_VALUE;
      }
 
      if(auto name = extract_general_name_at(c.issuer_alt_name(), index)) {
         return ffi_new_object(alt_name, std::make_unique<Botan::GeneralName>(std::move(name).value()));
      }
 
      return BOTAN_FFI_ERROR_OUT_OF_RANGE;
   });
#else
   BOTAN_UNUSED(cert, index, alt_name);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References Botan::any_null_pointers(), BOTAN_FFI_ERROR_NO_VALUE, BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_ERROR_OUT_OF_RANGE, BOTAN_FFI_VISIT, BOTAN_UNUSED, Botan::Extensions::extension_set(), Botan_FFI::ffi_new_object(), Botan::OID::from_string(), Botan::X509_Certificate::issuer_alt_name(), and Botan::X509_Certificate::v3_extensions().

botan_x509_cert_issuer_alternative_names_count()

int botan_x509_cert_issuer_alternative_names_count	(	botan_x509_cert_t	cert,
		size_t *	count )

Definition at line 946 of file ffi_cert.cpp.

                                                                                          {
#if defined(BOTAN_HAS_X509_CERTIFICATES)
   if(Botan::any_null_pointers(count)) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
 
   return BOTAN_FFI_VISIT(
      cert, [=](const Botan::X509_Certificate& c) { *count = count_general_names_in(c.issuer_alt_name()); });
#else
   BOTAN_UNUSED(cert, count);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References Botan::any_null_pointers(), BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_VISIT, BOTAN_UNUSED, and Botan::X509_Certificate::issuer_alt_name().

botan_x509_cert_load()

int botan_x509_cert_load	(	botan_x509_cert_t *	cert_obj,
		const uint8_t	cert[],
		size_t	cert_len )

Definition at line 212 of file ffi_cert.cpp.

                                                                                                       {
   if(cert_obj == nullptr || cert_bits == nullptr) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
 
#if defined(BOTAN_HAS_X509_CERTIFICATES)
   return ffi_guard_thunk(__func__, [=]() -> int {
      Botan::DataSource_Memory bits(cert_bits, cert_bits_len);
      auto c = std::make_unique<Botan::X509_Certificate>(bits);
      return ffi_new_object(cert_obj, std::move(c));
   });
#else
   BOTAN_UNUSED(cert_bits_len);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_UNUSED, Botan_FFI::ffi_guard_thunk(), and Botan_FFI::ffi_new_object().

botan_x509_cert_load_file()

int botan_x509_cert_load_file	(	botan_x509_cert_t *	cert_obj,
		const char *	filename )

Definition at line 177 of file ffi_cert.cpp.

                                                                                  {
   if(cert_obj == nullptr || cert_path == nullptr) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
 
#if defined(BOTAN_HAS_X509_CERTIFICATES) && defined(BOTAN_TARGET_OS_HAS_FILESYSTEM)
 
   return ffi_guard_thunk(__func__, [=]() -> int {
      auto c = std::make_unique<Botan::X509_Certificate>(cert_path);
      return ffi_new_object(cert_obj, std::move(c));
   });
 
#else
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, Botan_FFI::ffi_guard_thunk(), and Botan_FFI::ffi_new_object().

botan_x509_cert_not_after()

int botan_x509_cert_not_after	(	botan_x509_cert_t	cert,
		uint64_t *	time_since_epoch )

Definition at line 648 of file ffi_cert.cpp.

                                                                                  {
   if(time_since_epoch == nullptr) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
#if defined(BOTAN_HAS_X509_CERTIFICATES)
   return BOTAN_FFI_VISIT(cert, [=](const auto& c) { *time_since_epoch = c.not_after().time_since_epoch(); });
#else
   BOTAN_UNUSED(cert, time_since_epoch);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_VISIT, and BOTAN_UNUSED.

botan_x509_cert_not_before()

int botan_x509_cert_not_before	(	botan_x509_cert_t	cert,
		uint64_t *	time_since_epoch )

Definition at line 636 of file ffi_cert.cpp.

                                                                                   {
   if(time_since_epoch == nullptr) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
#if defined(BOTAN_HAS_X509_CERTIFICATES)
   return BOTAN_FFI_VISIT(cert, [=](const auto& c) { *time_since_epoch = c.not_before().time_since_epoch(); });
#else
   BOTAN_UNUSED(cert, time_since_epoch);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_VISIT, and BOTAN_UNUSED.

botan_x509_cert_permitted_name_constraints()

int botan_x509_cert_permitted_name_constraints	(	botan_x509_cert_t	cert,
		size_t	index,
		botan_x509_general_name_t *	constraint )

Extracts "permitted" name constraints from a given cert one-by-one. Returns BOTAN_FFI_ERROR_OUT_OF_RANGE if the given index is larger than the available number of "permitted" name constraints.

Definition at line 812 of file ffi_cert.cpp.

                                                                                      {
#if defined(BOTAN_HAS_X509_CERTIFICATES)
   return BOTAN_FFI_VISIT(cert, [=](const Botan::X509_Certificate& c) {
      if(Botan::any_null_pointers(constraint)) {
         return BOTAN_FFI_ERROR_NULL_POINTER;
      }
 
      const auto& constraints = c.name_constraints().permitted();
      if(index >= constraints.size()) {
         return BOTAN_FFI_ERROR_OUT_OF_RANGE;
      }
 
      return ffi_new_object(constraint, std::make_unique<Botan::GeneralName>(constraints[index].base()));
   });
#else
   BOTAN_UNUSED(cert, index, constraint);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References Botan::any_null_pointers(), BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_ERROR_OUT_OF_RANGE, BOTAN_FFI_VISIT, BOTAN_UNUSED, Botan_FFI::ffi_new_object(), Botan::X509_Certificate::name_constraints(), and Botan::NameConstraints::permitted().

botan_x509_cert_permitted_name_constraints_count()

int botan_x509_cert_permitted_name_constraints_count	(	botan_x509_cert_t	cert,
		size_t *	count )

Definition at line 834 of file ffi_cert.cpp.

                                                                                            {
#if defined(BOTAN_HAS_X509_CERTIFICATES)
   if(Botan::any_null_pointers(count)) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
 
   return BOTAN_FFI_VISIT(cert, [=](const auto& c) { *count = c.name_constraints().permitted().size(); });
#else
   BOTAN_UNUSED(cert, count);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References Botan::any_null_pointers(), BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_VISIT, and BOTAN_UNUSED.

botan_x509_cert_serial_number()

int botan_x509_cert_serial_number	(	botan_x509_cert_t	cert,
		botan_mp_t *	serial_number )

Definition at line 669 of file ffi_cert.cpp.

                                                                                     {
#if defined(BOTAN_HAS_X509_CERTIFICATES)
   return BOTAN_FFI_VISIT(cert, [=](const Botan::X509_Certificate& c) {
      if(Botan::any_null_pointers(serial_number)) {
         return BOTAN_FFI_ERROR_NULL_POINTER;
      }
 
      auto serial_bn = Botan::BigInt::from_bytes(c.serial_number());
      return ffi_new_object(serial_number, std::make_unique<Botan::BigInt>(std::move(serial_bn)));
   });
#else
   BOTAN_UNUSED(cert, serial_number);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References Botan::any_null_pointers(), BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_VISIT, BOTAN_UNUSED, Botan_FFI::ffi_new_object(), Botan::BigInt::from_bytes(), and Botan::X509_Certificate::serial_number().

botan_x509_cert_subject_alternative_names()

int botan_x509_cert_subject_alternative_names	(	botan_x509_cert_t	cert,
		size_t	index,
		botan_x509_general_name_t *	alt_name )

Provides access to all "subject alternative names", where each entry is returned as a botan_x509_general_name_t. If the given index is not within range of the available entries, BOTAN_FFI_ERROR_OUT_OF_RANGE is returned. If cert does not contain a SubjectAlternativeNames extension, BOTAN_FFI_ERROR_NO_VALUE is returned.

Definition at line 882 of file ffi_cert.cpp.

                                                                                   {
#if defined(BOTAN_HAS_X509_CERTIFICATES)
   return BOTAN_FFI_VISIT(cert, [=](const Botan::X509_Certificate& c) {
      if(Botan::any_null_pointers(alt_name)) {
         return BOTAN_FFI_ERROR_NULL_POINTER;
      }
 
      if(!c.v3_extensions().extension_set(Botan::OID::from_string("X509v3.SubjectAlternativeName"))) {
         return BOTAN_FFI_ERROR_NO_VALUE;
      }
 
      if(auto name = extract_general_name_at(c.subject_alt_name(), index)) {
         return ffi_new_object(alt_name, std::make_unique<Botan::GeneralName>(std::move(name).value()));
      }
 
      return BOTAN_FFI_ERROR_OUT_OF_RANGE;
   });
#else
   BOTAN_UNUSED(cert, index, alt_name);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References Botan::any_null_pointers(), BOTAN_FFI_ERROR_NO_VALUE, BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_ERROR_OUT_OF_RANGE, BOTAN_FFI_VISIT, BOTAN_UNUSED, Botan::Extensions::extension_set(), Botan_FFI::ffi_new_object(), Botan::OID::from_string(), Botan::X509_Certificate::subject_alt_name(), and Botan::X509_Certificate::v3_extensions().

botan_x509_cert_subject_alternative_names_count()

int botan_x509_cert_subject_alternative_names_count	(	botan_x509_cert_t	cert,
		size_t *	count )

Definition at line 907 of file ffi_cert.cpp.

                                                                                           {
#if defined(BOTAN_HAS_X509_CERTIFICATES)
   if(Botan::any_null_pointers(count)) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
 
   return BOTAN_FFI_VISIT(
      cert, [=](const Botan::X509_Certificate& c) { *count = count_general_names_in(c.subject_alt_name()); });
#else
   BOTAN_UNUSED(cert, count);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References Botan::any_null_pointers(), BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_VISIT, BOTAN_UNUSED, and Botan::X509_Certificate::subject_alt_name().

botan_x509_cert_to_string()

int botan_x509_cert_to_string	(	botan_x509_cert_t	cert,
		char	out[],
		size_t *	out_len )

Definition at line 555 of file ffi_cert.cpp.

                                                                                   {
   return copy_view_str(reinterpret_cast<uint8_t*>(out), out_len, botan_x509_cert_view_as_string, cert);
}

References botan_x509_cert_view_as_string(), and Botan_FFI::copy_view_str().

botan_x509_cert_validation_status()

const char * botan_x509_cert_validation_status

(

int

code

)

Returns a pointer to a static character string explaining the status code, or else NULL if unknown.

Definition at line 1040 of file ffi_cert.cpp.

                                                        {
   if(code < 0) {
      return nullptr;
   }
 
#if defined(BOTAN_HAS_X509_CERTIFICATES)
   const Botan::Certificate_Status_Code sc = static_cast<Botan::Certificate_Status_Code>(code);
   return Botan::to_string(sc);
#else
   return nullptr;
#endif
}

References Botan::to_string().

botan_x509_cert_verify()

int botan_x509_cert_verify	(	int *	validation_result,
		botan_x509_cert_t	cert,
		const botan_x509_cert_t *	intermediates,
		size_t	intermediates_len,
		const botan_x509_cert_t *	trusted,
		size_t	trusted_len,
		const char *	trusted_path,
		size_t	required_strength,
		const char *	hostname,
		uint64_t	reference_time )

Returns 0 if the validation was successful, 1 if validation failed, and negative on error. A status code with details is written to *validation_result

Intermediates or trusted lists can be null Trusted path can be null

Definition at line 973 of file ffi_cert.cpp.

                                                    {
   if(required_strength == 0) {
      required_strength = 110;
   }
 
#if defined(BOTAN_HAS_X509_CERTIFICATES)
   return ffi_guard_thunk(__func__, [=]() -> int {
      const std::string hostname((hostname_cstr == nullptr) ? "" : hostname_cstr);
      const Botan::Usage_Type usage = Botan::Usage_Type::UNSPECIFIED;
      const auto validation_time = reference_time == 0
                                      ? std::chrono::system_clock::now()
                                      : std::chrono::system_clock::from_time_t(static_cast<time_t>(reference_time));
 
      std::vector<Botan::X509_Certificate> end_certs;
      end_certs.push_back(safe_get(cert));
      for(size_t i = 0; i != intermediates_len; ++i) {
         end_certs.push_back(safe_get(intermediates[i]));
      }
 
      std::unique_ptr<Botan::Certificate_Store> trusted_from_path;
      std::unique_ptr<Botan::Certificate_Store_In_Memory> trusted_extra;
      std::vector<Botan::Certificate_Store*> trusted_roots;
 
      if(trusted_path != nullptr && *trusted_path != 0) {
         trusted_from_path = std::make_unique<Botan::Certificate_Store_In_Memory>(trusted_path);
         trusted_roots.push_back(trusted_from_path.get());
      }
 
      if(trusted_len > 0) {
         trusted_extra = std::make_unique<Botan::Certificate_Store_In_Memory>();
         for(size_t i = 0; i != trusted_len; ++i) {
            trusted_extra->add_certificate(safe_get(trusted[i]));
         }
         trusted_roots.push_back(trusted_extra.get());
      }
 
      const Botan::Path_Validation_Restrictions restrictions(false, required_strength);
 
      auto validation_result =
         Botan::x509_path_validate(end_certs, restrictions, trusted_roots, hostname, usage, validation_time);
 
      if(result_code != nullptr) {
         *result_code = static_cast<int>(validation_result.result());
      }
 
      if(validation_result.successful_validation()) {
         return 0;
      } else {
         return 1;
      }
   });
#else
   BOTAN_UNUSED(result_code, cert, intermediates, intermediates_len, trusted);
   BOTAN_UNUSED(trusted_len, trusted_path, hostname_cstr, reference_time);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_UNUSED, Botan_FFI::ffi_guard_thunk(), Botan_FFI::safe_get(), Botan::UNSPECIFIED, and Botan::x509_path_validate().

botan_x509_cert_verify_with_crl()

int botan_x509_cert_verify_with_crl	(	int *	validation_result,
		botan_x509_cert_t	cert,
		const botan_x509_cert_t *	intermediates,
		size_t	intermediates_len,
		const botan_x509_cert_t *	trusted,
		size_t	trusted_len,
		const botan_x509_crl_t *	crls,
		size_t	crls_len,
		const char *	trusted_path,
		size_t	required_strength,
		const char *	hostname,
		uint64_t	reference_time )

Different flavor of botan_x509_cert_verify, supports revocation lists. CRLs are passed as an array, same as intermediates and trusted CAs

Definition at line 1443 of file ffi_cert.cpp.

                                                             {
   if(required_strength == 0) {
      required_strength = 110;
   }
 
#if defined(BOTAN_HAS_X509_CERTIFICATES)
   return ffi_guard_thunk(__func__, [=]() -> int {
      const std::string hostname((hostname_cstr == nullptr) ? "" : hostname_cstr);
      const Botan::Usage_Type usage = Botan::Usage_Type::UNSPECIFIED;
      const auto validation_time = reference_time == 0
                                      ? std::chrono::system_clock::now()
                                      : std::chrono::system_clock::from_time_t(static_cast<time_t>(reference_time));
 
      std::vector<Botan::X509_Certificate> end_certs;
      end_certs.push_back(safe_get(cert));
      for(size_t i = 0; i != intermediates_len; ++i) {
         end_certs.push_back(safe_get(intermediates[i]));
      }
 
      std::unique_ptr<Botan::Certificate_Store> trusted_from_path;
      std::unique_ptr<Botan::Certificate_Store_In_Memory> trusted_extra;
      std::unique_ptr<Botan::Certificate_Store_In_Memory> trusted_crls;
      std::vector<Botan::Certificate_Store*> trusted_roots;
 
      if(trusted_path != nullptr && *trusted_path != 0) {
         trusted_from_path = std::make_unique<Botan::Certificate_Store_In_Memory>(trusted_path);
         trusted_roots.push_back(trusted_from_path.get());
      }
 
      if(trusted_len > 0) {
         trusted_extra = std::make_unique<Botan::Certificate_Store_In_Memory>();
         for(size_t i = 0; i != trusted_len; ++i) {
            trusted_extra->add_certificate(safe_get(trusted[i]));
         }
         trusted_roots.push_back(trusted_extra.get());
      }
 
      if(crls_len > 0) {
         trusted_crls = std::make_unique<Botan::Certificate_Store_In_Memory>();
         for(size_t i = 0; i != crls_len; ++i) {
            trusted_crls->add_crl(safe_get(crls[i]));
         }
         trusted_roots.push_back(trusted_crls.get());
      }
 
      const Botan::Path_Validation_Restrictions restrictions(false, required_strength);
 
      auto validation_result =
         Botan::x509_path_validate(end_certs, restrictions, trusted_roots, hostname, usage, validation_time);
 
      if(result_code != nullptr) {
         *result_code = static_cast<int>(validation_result.result());
      }
 
      if(validation_result.successful_validation()) {
         return 0;
      } else {
         return 1;
      }
   });
#else
   BOTAN_UNUSED(result_code, cert, intermediates, intermediates_len, trusted);
   BOTAN_UNUSED(trusted_len, trusted_path, hostname_cstr, reference_time, crls, crls_len);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_UNUSED, Botan_FFI::ffi_guard_thunk(), Botan_FFI::safe_get(), Botan::UNSPECIFIED, and Botan::x509_path_validate().

botan_x509_cert_view_as_string()

int botan_x509_cert_view_as_string	(	botan_x509_cert_t	cert,
		botan_view_ctx	ctx,
		botan_view_str_fn	view )

Definition at line 559 of file ffi_cert.cpp.

                                                                                                       {
#if defined(BOTAN_HAS_X509_CERTIFICATES)
   return BOTAN_FFI_VISIT(cert, [=](const auto& c) { return invoke_view_callback(view, ctx, c.to_string()); });
#else
   BOTAN_UNUSED(cert, ctx, view);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_VISIT, BOTAN_UNUSED, and Botan_FFI::invoke_view_callback().

Referenced by botan_x509_cert_to_string().

botan_x509_cert_view_binary_values()

int botan_x509_cert_view_binary_values	(	botan_x509_cert_t	cert,
		botan_x509_value_type	value_type,
		size_t	index,
		botan_view_ctx	ctx,
		botan_view_bin_fn	view )

Retrieve a specific binary value from an X.509 certificate.

For multi-values index allows enumerating the available entries, until BOTAN_FFI_ERROR_OUT_OF_RANGE is returned. For singleton values, an index of value "0" is expected.

Returns

BOTAN_FFI_ERROR_NO_VALUE if the provided cert does not provide the requested value_type at all or not in binary format.

Definition at line 286 of file ffi_cert.cpp.

                                                                  {
#if defined(BOTAN_HAS_X509_CERTIFICATES)
   if(index != 0) {
      // As of now there are no multi-value binary entries.
      return BOTAN_FFI_ERROR_OUT_OF_RANGE;
   }
 
   auto view = [=](std::span<const uint8_t> value) -> int {
      if(value.empty()) {
         return BOTAN_FFI_ERROR_NO_VALUE;
      } else {
         return invoke_view_callback(view_fn, ctx, value);
      }
   };
 
   return BOTAN_FFI_VISIT(cert, [=](const Botan::X509_Certificate& c) -> int {
      switch(value_type) {
         case BOTAN_X509_SERIAL_NUMBER:
            return view(c.serial_number());
         case BOTAN_X509_SUBJECT_DN_BITS:
            return view(c.raw_subject_dn());
         case BOTAN_X509_ISSUER_DN_BITS:
            return view(c.raw_issuer_dn());
         case BOTAN_X509_SUBJECT_KEY_IDENTIFIER:
            return view(c.subject_key_id());
         case BOTAN_X509_AUTHORITY_KEY_IDENTIFIER:
            return view(c.authority_key_id());
         case BOTAN_X509_PUBLIC_KEY_PKCS8_BITS:
            return view(c.subject_public_key_info());
 
         case BOTAN_X509_TBS_DATA_BITS:
         case BOTAN_X509_SIGNATURE_SCHEME_BITS:
         case BOTAN_X509_SIGNATURE_BITS:
         case BOTAN_X509_DER_ENCODING:
            return botan_x509_object_view_value(c, value_type, index, ctx, view_fn);
 
         case BOTAN_X509_PEM_ENCODING:
         case BOTAN_X509_CRL_DISTRIBUTION_URLS:
         case BOTAN_X509_OCSP_RESPONDER_URLS:
         case BOTAN_X509_CA_ISSUERS_URLS:
            return BOTAN_FFI_ERROR_NO_VALUE;
      }
 
      return BOTAN_FFI_ERROR_BAD_PARAMETER;
   });
#else
   BOTAN_UNUSED(cert, value_type, index, ctx, view_fn);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References Botan::X509_Certificate::authority_key_id(), BOTAN_FFI_ERROR_BAD_PARAMETER, BOTAN_FFI_ERROR_NO_VALUE, BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_OUT_OF_RANGE, BOTAN_FFI_VISIT, BOTAN_UNUSED, BOTAN_X509_AUTHORITY_KEY_IDENTIFIER, BOTAN_X509_CA_ISSUERS_URLS, BOTAN_X509_CRL_DISTRIBUTION_URLS, BOTAN_X509_DER_ENCODING, BOTAN_X509_ISSUER_DN_BITS, BOTAN_X509_OCSP_RESPONDER_URLS, BOTAN_X509_PEM_ENCODING, BOTAN_X509_PUBLIC_KEY_PKCS8_BITS, BOTAN_X509_SERIAL_NUMBER, BOTAN_X509_SIGNATURE_BITS, BOTAN_X509_SIGNATURE_SCHEME_BITS, BOTAN_X509_SUBJECT_DN_BITS, BOTAN_X509_SUBJECT_KEY_IDENTIFIER, BOTAN_X509_TBS_DATA_BITS, Botan_FFI::invoke_view_callback(), Botan::X509_Certificate::raw_issuer_dn(), Botan::X509_Certificate::raw_subject_dn(), Botan::X509_Certificate::serial_number(), Botan::X509_Certificate::subject_key_id(), and Botan::X509_Certificate::subject_public_key_info().

Referenced by botan_x509_cert_view_binary_values_count().

botan_x509_cert_view_binary_values_count()

int botan_x509_cert_view_binary_values_count	(	botan_x509_cert_t	cert,
		botan_x509_value_type	value_type,
		size_t *	count )

Definition at line 341 of file ffi_cert.cpp.

                                                                                                                      {
#if defined(BOTAN_HAS_X509_CERTIFICATES)
   return enumerator_count_values(count, [=](size_t index) {
      return botan_x509_cert_view_binary_values(
         cert, value_type, index, nullptr, [](auto, auto, auto) -> int { return BOTAN_FFI_SUCCESS; });
   });
#else
   BOTAN_UNUSED(cert, value_type, count);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_SUCCESS, BOTAN_UNUSED, and botan_x509_cert_view_binary_values().

botan_x509_cert_view_public_key_bits()

int botan_x509_cert_view_public_key_bits	(	botan_x509_cert_t	cert,
		botan_view_ctx	ctx,
		botan_view_bin_fn	view )

Definition at line 723 of file ffi_cert.cpp.

                                                                                                             {
#if defined(BOTAN_HAS_X509_CERTIFICATES)
   return BOTAN_FFI_VISIT(cert,
                          [=](const auto& c) { return invoke_view_callback(view, ctx, c.subject_public_key_bits()); });
#else
   BOTAN_UNUSED(cert, ctx, view);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_VISIT, BOTAN_UNUSED, and Botan_FFI::invoke_view_callback().

Referenced by botan_x509_cert_get_public_key_bits().

botan_x509_cert_view_string_values()

int botan_x509_cert_view_string_values	(	botan_x509_cert_t	cert,
		botan_x509_value_type	value_type,
		size_t	index,
		botan_view_ctx	ctx,
		botan_view_str_fn	view )

Retrieve a specific string value from an X.509 certificate.

For multi-values index allows enumerating the available entries, until BOTAN_FFI_ERROR_OUT_OF_RANGE is returned. For singleton values, an index of value "0" is expected.

Returns

BOTAN_FFI_ERROR_NO_VALUE if the provided cert does not provide the requested value_type at all or not in string format.

Definition at line 353 of file ffi_cert.cpp.

                                                                  {
#if defined(BOTAN_HAS_X509_CERTIFICATES)
   auto enumerate = [view_fn, ctx](auto values, size_t idx) -> int {
      if(idx >= values.size()) {
         return BOTAN_FFI_ERROR_OUT_OF_RANGE;
      } else {
         return invoke_view_callback(view_fn, ctx, values[idx]);
      }
   };
 
   auto enumerate_crl_distribution_points = [view_fn, ctx](const Botan::X509_Certificate& c, size_t idx) -> int {
      const auto* crl_dp_ext =
         c.v3_extensions().get_extension_object_as<Botan::Cert_Extension::CRL_Distribution_Points>();
      if(crl_dp_ext == nullptr) {
         return BOTAN_FFI_ERROR_OUT_OF_RANGE;  // essentially an empty list
      }
 
      const auto& dps = crl_dp_ext->distribution_points();
      for(size_t i = idx; const auto& dp : dps) {
         const auto& uris = dp.point().uris();
         if(i >= uris.size()) {
            i -= uris.size();
            continue;
         }
 
         auto itr = uris.begin();
         std::advance(itr, i);
         return invoke_view_callback(view_fn, ctx, *itr);
      }
 
      return BOTAN_FFI_ERROR_OUT_OF_RANGE;
   };
 
   return BOTAN_FFI_VISIT(cert, [=](const Botan::X509_Certificate& c) -> int {
      switch(value_type) {
         case BOTAN_X509_CRL_DISTRIBUTION_URLS:
            return enumerate_crl_distribution_points(c, index);
         case BOTAN_X509_OCSP_RESPONDER_URLS:
            return enumerate(c.ocsp_responders(), index);
         case BOTAN_X509_CA_ISSUERS_URLS:
            return enumerate(c.ca_issuers(), index);
         case BOTAN_X509_PEM_ENCODING:
            return botan_x509_object_view_value(c, value_type, index, ctx, view_fn);
 
         case BOTAN_X509_SERIAL_NUMBER:
         case BOTAN_X509_SUBJECT_DN_BITS:
         case BOTAN_X509_ISSUER_DN_BITS:
         case BOTAN_X509_SUBJECT_KEY_IDENTIFIER:
         case BOTAN_X509_AUTHORITY_KEY_IDENTIFIER:
         case BOTAN_X509_PUBLIC_KEY_PKCS8_BITS:
         case BOTAN_X509_TBS_DATA_BITS:
         case BOTAN_X509_SIGNATURE_SCHEME_BITS:
         case BOTAN_X509_SIGNATURE_BITS:
         case BOTAN_X509_DER_ENCODING:
            return BOTAN_FFI_ERROR_NO_VALUE;
      }
 
      return BOTAN_FFI_ERROR_BAD_PARAMETER;
   });
#else
   BOTAN_UNUSED(cert, value_type, index, ctx, view_fn);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References BOTAN_FFI_ERROR_BAD_PARAMETER, BOTAN_FFI_ERROR_NO_VALUE, BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_OUT_OF_RANGE, BOTAN_FFI_VISIT, BOTAN_UNUSED, BOTAN_X509_AUTHORITY_KEY_IDENTIFIER, BOTAN_X509_CA_ISSUERS_URLS, BOTAN_X509_CRL_DISTRIBUTION_URLS, BOTAN_X509_DER_ENCODING, BOTAN_X509_ISSUER_DN_BITS, BOTAN_X509_OCSP_RESPONDER_URLS, BOTAN_X509_PEM_ENCODING, BOTAN_X509_PUBLIC_KEY_PKCS8_BITS, BOTAN_X509_SERIAL_NUMBER, BOTAN_X509_SIGNATURE_BITS, BOTAN_X509_SIGNATURE_SCHEME_BITS, BOTAN_X509_SUBJECT_DN_BITS, BOTAN_X509_SUBJECT_KEY_IDENTIFIER, BOTAN_X509_TBS_DATA_BITS, Botan::Cert_Extension::CRL_Distribution_Points::distribution_points(), and Botan_FFI::invoke_view_callback().

Referenced by botan_x509_cert_view_string_values_count().

botan_x509_cert_view_string_values_count()

int botan_x509_cert_view_string_values_count	(	botan_x509_cert_t	cert,
		botan_x509_value_type	value_type,
		size_t *	count )

Definition at line 422 of file ffi_cert.cpp.

                                                                                                                      {
#if defined(BOTAN_HAS_X509_CERTIFICATES)
   return enumerator_count_values(count, [=](size_t index) {
      return botan_x509_cert_view_string_values(
         cert, value_type, index, nullptr, [](auto, auto, auto) -> int { return BOTAN_FFI_SUCCESS; });
   });
#else
   BOTAN_UNUSED(cert, value_type, count);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_SUCCESS, BOTAN_UNUSED, and botan_x509_cert_view_string_values().

botan_x509_crl_create()

int botan_x509_crl_create	(	botan_x509_crl_t *	crl_obj,
		botan_rng_t	rng,
		botan_x509_cert_t	ca_cert,
		botan_privkey_t	ca_key,
		uint64_t	issue_time,
		uint32_t	next_update,
		const char *	hash_fn,
		const char *	padding )

Create a new CRL

Parameters

crl_obj	The newly created CRL
Random Number Generators	a random number generator object
ca_cert	The CA Certificate the CRL belongs to
ca_key	The private key of that CA
issue_time	The time when the CRL becomes valid
next_update	The number of seconds after issue_time until the CRL expires
hash_fn	The hash function to use, may be null
padding	The padding to use, may be null

Definition at line 1123 of file ffi_cert.cpp.

                                               {
   if(Botan::any_null_pointers(crl_obj)) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
#if defined(BOTAN_HAS_X509_CERTIFICATES)
   return ffi_guard_thunk(__func__, [=]() -> int {
      auto& rng_ = safe_get(rng);
      auto ca = Botan::X509_CA(
         safe_get(ca_cert), safe_get(ca_key), default_from_ptr(hash_fn), default_from_ptr(padding), rng_);
      auto crl = std::make_unique<Botan::X509_CRL>(
         ca.new_crl(rng_, timepoint_from_timestamp(issue_time), std::chrono::seconds(next_update)));
      return ffi_new_object(crl_obj, std::move(crl));
   });
#else
   BOTAN_UNUSED(rng, ca_cert, ca_key, hash_fn, padding, issue_time, next_update);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References Botan::any_null_pointers(), BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_UNUSED, Botan_FFI::ffi_guard_thunk(), Botan_FFI::ffi_new_object(), and Botan_FFI::safe_get().

botan_x509_crl_destroy()

int botan_x509_crl_destroy

(

botan_x509_crl_t

crl

)

Definition at line 1213 of file ffi_cert.cpp.

                                                 {
#if defined(BOTAN_HAS_X509_CERTIFICATES)
   return BOTAN_FFI_CHECKED_DELETE(crl);
#else
   BOTAN_UNUSED(crl);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References BOTAN_FFI_CHECKED_DELETE, BOTAN_FFI_ERROR_NOT_IMPLEMENTED, and BOTAN_UNUSED.

botan_x509_crl_entries()

int botan_x509_crl_entries	(	botan_x509_crl_t	crl,
		size_t	index,
		botan_x509_crl_entry_t *	entry )

Allows iterating all entries of the CRL.

Parameters

crl	the CRL whose entries should be listed
index	the index of the CRL entry to return
entry	an object handle containing the CRL entry data

Returns

BOTAN_FFI_ERROR_OUT_OF_RANGE if the given index is out of range of the CRL entry list.

Definition at line 1343 of file ffi_cert.cpp.

                                                                                              {
#if defined(BOTAN_HAS_X509_CERTIFICATES)
   return BOTAN_FFI_VISIT(crl, [=](const Botan::X509_CRL& c) -> int {
      const auto& entries = c.get_revoked();
      if(index >= entries.size()) {
         return BOTAN_FFI_ERROR_OUT_OF_RANGE;
      }
 
      if(Botan::any_null_pointers(entry)) {
         return BOTAN_FFI_ERROR_NULL_POINTER;
      }
 
      return ffi_new_object(entry, std::make_unique<Botan::CRL_Entry>(entries[index]));
   });
#else
   BOTAN_UNUSED(crl, index, entry);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References Botan::any_null_pointers(), BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_ERROR_OUT_OF_RANGE, BOTAN_FFI_VISIT, BOTAN_UNUSED, Botan_FFI::ffi_new_object(), and Botan::X509_CRL::get_revoked().

botan_x509_crl_entries_count()

int botan_x509_crl_entries_count	(	botan_x509_crl_t	crl,
		size_t *	count )

Definition at line 1363 of file ffi_cert.cpp.

                                                                      {
#if defined(BOTAN_HAS_X509_CERTIFICATES)
   if(Botan::any_null_pointers(count)) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
 
   return BOTAN_FFI_VISIT(crl, [=](const Botan::X509_CRL& c) { *count = c.get_revoked().size(); });
#else
   BOTAN_UNUSED(crl, count);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References Botan::any_null_pointers(), BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_VISIT, BOTAN_UNUSED, and Botan::X509_CRL::get_revoked().

botan_x509_crl_entry_create()

int botan_x509_crl_entry_create	(	botan_x509_crl_entry_t *	entry,
		botan_x509_cert_t	cert,
		int	reason_code )

Create a new CRL entry that marks cert as revoked

Parameters

entry	The newly created CRL entry
cert	The certificate to mark as revoked
reason_code	The reason code for revocation

Definition at line 1149 of file ffi_cert.cpp.

                                                                                                        {
   if(Botan::any_null_pointers(entry)) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
#if defined(BOTAN_HAS_X509_CERTIFICATES)
   return ffi_guard_thunk(__func__, [=]() -> int {
      return ffi_new_object(
         entry, std::make_unique<Botan::CRL_Entry>(safe_get(cert), static_cast<Botan::CRL_Code>(reason_code)));
   });
#else
   BOTAN_UNUSED(cert, reason_code);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References Botan::any_null_pointers(), BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_UNUSED, Botan_FFI::ffi_guard_thunk(), Botan_FFI::ffi_new_object(), and Botan_FFI::safe_get().

botan_x509_crl_entry_destroy()

int botan_x509_crl_entry_destroy

(

botan_x509_crl_entry_t

entry

)

Definition at line 1376 of file ffi_cert.cpp.

                                                               {
#if defined(BOTAN_HAS_X509_CERTIFICATES)
   return BOTAN_FFI_CHECKED_DELETE(entry);
#else
   BOTAN_UNUSED(entry);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References BOTAN_FFI_CHECKED_DELETE, BOTAN_FFI_ERROR_NOT_IMPLEMENTED, and BOTAN_UNUSED.

botan_x509_crl_entry_reason()

int botan_x509_crl_entry_reason	(	botan_x509_crl_entry_t	entry,
		int *	reason_code )

Return the revocation reason code for the given CRL entry. See botan_x509_crl_reason_code and RFC 5280 - 5.3.1 for possible reason codes.

Definition at line 1385 of file ffi_cert.cpp.

                                                                                {
#if defined(BOTAN_HAS_X509_CERTIFICATES)
   return BOTAN_FFI_VISIT(entry, [=](const Botan::CRL_Entry& e) {
      if(Botan::any_null_pointers(reason_code)) {
         return BOTAN_FFI_ERROR_NULL_POINTER;
      }
 
      *reason_code = static_cast<int>(e.reason_code());
      return BOTAN_FFI_SUCCESS;
   });
#else
   BOTAN_UNUSED(entry, reason_code);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References Botan::any_null_pointers(), BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_SUCCESS, BOTAN_FFI_VISIT, BOTAN_UNUSED, and Botan::CRL_Entry::reason_code().

botan_x509_crl_entry_revocation_date()

int botan_x509_crl_entry_revocation_date	(	botan_x509_crl_entry_t	entry,
		uint64_t *	time_since_epoch )

Return the revocation date for the given CRL entry as time since epoch in seconds.

Definition at line 1427 of file ffi_cert.cpp.

                                                                                                   {
#if defined(BOTAN_HAS_X509_CERTIFICATES)
   return BOTAN_FFI_VISIT(entry, [=](const Botan::CRL_Entry& e) {
      if(Botan::any_null_pointers(time_since_epoch)) {
         return BOTAN_FFI_ERROR_NULL_POINTER;
      }
 
      *time_since_epoch = e.expire_time().time_since_epoch();
      return BOTAN_FFI_SUCCESS;
   });
#else
   BOTAN_UNUSED(entry, time_since_epoch);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References Botan::any_null_pointers(), BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_SUCCESS, BOTAN_FFI_VISIT, BOTAN_UNUSED, Botan::CRL_Entry::expire_time(), and Botan::ASN1_Time::time_since_epoch().

botan_x509_crl_entry_serial_number()

int botan_x509_crl_entry_serial_number	(	botan_x509_crl_entry_t	entry,
		botan_mp_t *	serial_number )

Return the serial number associated with the given CRL entry.

Definition at line 1401 of file ffi_cert.cpp.

                                                                                                {
#if defined(BOTAN_HAS_X509_CERTIFICATES)
   return BOTAN_FFI_VISIT(entry, [=](const Botan::CRL_Entry& e) {
      if(Botan::any_null_pointers(serial_number)) {
         return BOTAN_FFI_ERROR_NULL_POINTER;
      }
 
      auto serial_bn = Botan::BigInt::from_bytes(e.serial_number());
      return ffi_new_object(serial_number, std::make_unique<Botan::BigInt>(std::move(serial_bn)));
   });
#else
   BOTAN_UNUSED(entry, serial_number);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References Botan::any_null_pointers(), BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_VISIT, BOTAN_UNUSED, Botan_FFI::ffi_new_object(), Botan::BigInt::from_bytes(), and Botan::CRL_Entry::serial_number().

botan_x509_crl_entry_view_serial_number()

int botan_x509_crl_entry_view_serial_number	(	botan_x509_crl_entry_t	entry,
		botan_view_ctx	ctx,
		botan_view_bin_fn	view )

View the serial number associated with the given CRL entry.

Definition at line 1417 of file ffi_cert.cpp.

                                                                                                                      {
#if defined(BOTAN_HAS_X509_CERTIFICATES)
   return BOTAN_FFI_VISIT(
      entry, [=](const Botan::CRL_Entry& e) { return invoke_view_callback(view, ctx, e.serial_number()); });
#else
   BOTAN_UNUSED(entry, ctx, view);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_VISIT, BOTAN_UNUSED, Botan_FFI::invoke_view_callback(), and Botan::CRL_Entry::serial_number().

botan_x509_crl_load()

int botan_x509_crl_load	(	botan_x509_crl_t *	crl_obj,
		const uint8_t	crl_bits[],
		size_t	crl_bits_len )

Definition at line 1070 of file ffi_cert.cpp.

                                                                                                  {
   if(crl_obj == nullptr || crl_bits == nullptr) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
 
#if defined(BOTAN_HAS_X509_CERTIFICATES)
   return ffi_guard_thunk(__func__, [=]() -> int {
      Botan::DataSource_Memory bits(crl_bits, crl_bits_len);
      auto c = std::make_unique<Botan::X509_CRL>(bits);
      return ffi_new_object(crl_obj, std::move(c));
   });
#else
   BOTAN_UNUSED(crl_bits_len);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_UNUSED, Botan_FFI::ffi_guard_thunk(), and Botan_FFI::ffi_new_object().

botan_x509_crl_load_file()

int botan_x509_crl_load_file	(	botan_x509_crl_t *	crl_obj,
		const char *	crl_path )

Definition at line 1053 of file ffi_cert.cpp.

                                                                              {
   if(crl_obj == nullptr || crl_path == nullptr) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
 
#if defined(BOTAN_HAS_X509_CERTIFICATES) && defined(BOTAN_TARGET_OS_HAS_FILESYSTEM)
 
   return ffi_guard_thunk(__func__, [=]() -> int {
      auto c = std::make_unique<Botan::X509_CRL>(crl_path);
      return ffi_new_object(crl_obj, std::move(c));
   });
 
#else
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, Botan_FFI::ffi_guard_thunk(), and Botan_FFI::ffi_new_object().

botan_x509_crl_next_update()

int botan_x509_crl_next_update	(	botan_x509_crl_t	crl,
		uint64_t *	time_since_epoch )

Definition at line 1102 of file ffi_cert.cpp.

                                                                                 {
#if defined(BOTAN_HAS_X509_CERTIFICATES)
   return BOTAN_FFI_VISIT(crl, [=](const auto& c) {
      const auto& time = c.next_update();
      if(!time.time_is_set()) {
         return BOTAN_FFI_ERROR_NO_VALUE;
      }
 
      if(Botan::any_null_pointers(time_since_epoch)) {
         return BOTAN_FFI_ERROR_NULL_POINTER;
      }
 
      *time_since_epoch = c.next_update().time_since_epoch();
      return BOTAN_FFI_SUCCESS;
   });
#else
   BOTAN_UNUSED(crl, time_since_epoch);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References Botan::any_null_pointers(), BOTAN_FFI_ERROR_NO_VALUE, BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_SUCCESS, BOTAN_FFI_VISIT, and BOTAN_UNUSED.

botan_x509_crl_this_update()

int botan_x509_crl_this_update	(	botan_x509_crl_t	crl,
		uint64_t *	time_since_epoch )

Definition at line 1087 of file ffi_cert.cpp.

                                                                                 {
#if defined(BOTAN_HAS_X509_CERTIFICATES)
   return BOTAN_FFI_VISIT(crl, [=](const auto& c) {
      if(Botan::any_null_pointers(time_since_epoch)) {
         return BOTAN_FFI_ERROR_NULL_POINTER;
      }
      *time_since_epoch = c.this_update().time_since_epoch();
      return BOTAN_FFI_SUCCESS;
   });
#else
   BOTAN_UNUSED(crl, time_since_epoch);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References Botan::any_null_pointers(), BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_SUCCESS, BOTAN_FFI_VISIT, and BOTAN_UNUSED.

botan_x509_crl_update()

int botan_x509_crl_update	(	botan_x509_crl_t *	crl_obj,
		botan_x509_crl_t	last_crl,
		botan_rng_t	rng,
		botan_x509_cert_t	ca_cert,
		botan_privkey_t	ca_key,
		uint64_t	issue_time,
		uint32_t	next_update,
		const botan_x509_crl_entry_t *	new_entries,
		size_t	new_entries_len,
		const char *	hash_fn,
		const char *	padding )

Update a CRL with new revoked entries. This does not modify the old crl, and instead creates a new one.

Parameters

crl_obj	The newly created CRL
last_crl	The CRL to update
Random Number Generators	a random number generator object
ca_cert	The CA Certificate the CRL belongs to
ca_key	The private key of that CA
issue_time	The time when the CRL becomes valid
next_update	The number of seconds after issue_time until the CRL expires
new_entries	The entries to add to the CRL
new_entries_len	The number of entries
hash_fn	The hash function to use, may be null
padding	The padding to use, may be null

Definition at line 1164 of file ffi_cert.cpp.

                                               {
   if(Botan::any_null_pointers(crl_obj)) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
   if(new_entries_len > 0 && Botan::any_null_pointers(new_entries)) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
#if defined(BOTAN_HAS_X509_CERTIFICATES)
   return ffi_guard_thunk(__func__, [=]() -> int {
      auto& rng_ = safe_get(rng);
      auto ca = Botan::X509_CA(
         safe_get(ca_cert), safe_get(ca_key), default_from_ptr(hash_fn), default_from_ptr(padding), rng_);
 
      std::vector<Botan::CRL_Entry> entries;
      entries.reserve(new_entries_len);
      for(size_t i = 0; i < new_entries_len; i++) {
         entries.push_back(safe_get(new_entries[i]));
      }
 
      auto crl = std::make_unique<Botan::X509_CRL>(ca.update_crl(
         safe_get(last_crl), entries, rng_, timepoint_from_timestamp(issue_time), std::chrono::seconds(next_update)));
      return ffi_new_object(crl_obj, std::move(crl));
   });
#else
   BOTAN_UNUSED(
      last_crl, rng, ca_cert, ca_key, hash_fn, padding, issue_time, next_update, new_entries, new_entries_len);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References Botan::any_null_pointers(), BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_UNUSED, Botan_FFI::ffi_guard_thunk(), Botan_FFI::ffi_new_object(), and Botan_FFI::safe_get().

botan_x509_crl_verify_signature()

int botan_x509_crl_verify_signature	(	botan_x509_crl_t	crl,
		botan_pubkey_t	key )

Definition at line 1204 of file ffi_cert.cpp.

                                                                              {
#if defined(BOTAN_HAS_X509_CERTIFICATES)
   return BOTAN_FFI_VISIT(crl, [=](const auto& c) -> int { return c.check_signature(safe_get(key)) ? 1 : 0; });
#else
   BOTAN_UNUSED(crl, key);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_VISIT, BOTAN_UNUSED, and Botan_FFI::safe_get().

botan_x509_crl_view_binary_values()

int botan_x509_crl_view_binary_values	(	botan_x509_crl_t	crl_obj,
		botan_x509_value_type	value_type,
		size_t	index,
		botan_view_ctx	ctx,
		botan_view_bin_fn	view )

Retrieve a specific binary value from an X.509 certificate revocation list.

For multi-values index allows enumerating the available entries, until BOTAN_FFI_ERROR_OUT_OF_RANGE is returned. For singleton values, an index of value "0" is expected.

Returns

BOTAN_FFI_ERROR_NO_VALUE if the provided crl_obj does not provide the requested value_type at all or not in binary format.

Definition at line 1222 of file ffi_cert.cpp.

                                                                 {
#if defined(BOTAN_HAS_X509_CERTIFICATES)
   if(index != 0) {
      // As of now there are no multi-value binary entries.
      return BOTAN_FFI_ERROR_OUT_OF_RANGE;
   }
 
   auto view = [=](std::span<const uint8_t> value) -> int {
      if(value.empty()) {
         return BOTAN_FFI_ERROR_NO_VALUE;
      } else {
         return invoke_view_callback(view_fn, ctx, value);
      }
   };
 
   return BOTAN_FFI_VISIT(crl_obj, [=](const Botan::X509_CRL& crl) -> int {
      switch(value_type) {
         case BOTAN_X509_SERIAL_NUMBER:
            return view(Botan::store_be(crl.crl_number()));
         case BOTAN_X509_ISSUER_DN_BITS:
            return view(Botan::ASN1::put_in_sequence(crl.issuer_dn().get_bits()));
         case BOTAN_X509_AUTHORITY_KEY_IDENTIFIER:
            return view(crl.authority_key_id());
 
         case BOTAN_X509_TBS_DATA_BITS:
         case BOTAN_X509_SIGNATURE_SCHEME_BITS:
         case BOTAN_X509_SIGNATURE_BITS:
         case BOTAN_X509_DER_ENCODING:
            return botan_x509_object_view_value(crl, value_type, index, ctx, view_fn);
 
         case BOTAN_X509_SUBJECT_DN_BITS:
         case BOTAN_X509_SUBJECT_KEY_IDENTIFIER:
         case BOTAN_X509_PUBLIC_KEY_PKCS8_BITS:
         case BOTAN_X509_PEM_ENCODING:
         case BOTAN_X509_CRL_DISTRIBUTION_URLS:
         case BOTAN_X509_OCSP_RESPONDER_URLS:
         case BOTAN_X509_CA_ISSUERS_URLS:
            return BOTAN_FFI_ERROR_NO_VALUE;
      }
 
      return BOTAN_FFI_ERROR_BAD_PARAMETER;
   });
#else
   BOTAN_UNUSED(crl_obj, value_type, index, ctx, view_fn);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References Botan::X509_CRL::authority_key_id(), BOTAN_FFI_ERROR_BAD_PARAMETER, BOTAN_FFI_ERROR_NO_VALUE, BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_OUT_OF_RANGE, BOTAN_FFI_VISIT, BOTAN_UNUSED, BOTAN_X509_AUTHORITY_KEY_IDENTIFIER, BOTAN_X509_CA_ISSUERS_URLS, BOTAN_X509_CRL_DISTRIBUTION_URLS, BOTAN_X509_DER_ENCODING, BOTAN_X509_ISSUER_DN_BITS, BOTAN_X509_OCSP_RESPONDER_URLS, BOTAN_X509_PEM_ENCODING, BOTAN_X509_PUBLIC_KEY_PKCS8_BITS, BOTAN_X509_SERIAL_NUMBER, BOTAN_X509_SIGNATURE_BITS, BOTAN_X509_SIGNATURE_SCHEME_BITS, BOTAN_X509_SUBJECT_DN_BITS, BOTAN_X509_SUBJECT_KEY_IDENTIFIER, BOTAN_X509_TBS_DATA_BITS, Botan::X509_CRL::crl_number(), Botan::X509_DN::get_bits(), Botan_FFI::invoke_view_callback(), Botan::X509_CRL::issuer_dn(), Botan::ASN1::put_in_sequence(), and Botan::store_be().

Referenced by botan_x509_crl_view_binary_values_count().

botan_x509_crl_view_binary_values_count()

int botan_x509_crl_view_binary_values_count	(	botan_x509_crl_t	crl_obj,
		botan_x509_value_type	value_type,
		size_t *	count )

Definition at line 1274 of file ffi_cert.cpp.

                                                                                                                       {
#if defined(BOTAN_HAS_X509_CERTIFICATES)
   return enumerator_count_values(count, [=](size_t index) {
      return botan_x509_crl_view_binary_values(
         crl_obj, value_type, index, nullptr, [](auto, auto, auto) -> int { return BOTAN_FFI_SUCCESS; });
   });
#else
   BOTAN_UNUSED(crl_obj, value_type, count);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_SUCCESS, BOTAN_UNUSED, and botan_x509_crl_view_binary_values().

botan_x509_crl_view_string_values()

int botan_x509_crl_view_string_values	(	botan_x509_crl_t	crl_obj,
		botan_x509_value_type	value_type,
		size_t	index,
		botan_view_ctx	ctx,
		botan_view_str_fn	view )

Retrieve a specific string value from an X.509 certificate revocation list.

For multi-values index allows enumerating the available entries, until BOTAN_FFI_ERROR_OUT_OF_RANGE is returned. For singleton values, an index of value "0" is expected.

Returns

BOTAN_FFI_ERROR_NO_VALUE if the provided crl_obj does not provide the requested value_type at all or not in string format.

Definition at line 1286 of file ffi_cert.cpp.

                                                              {
#if defined(BOTAN_HAS_X509_CERTIFICATES)
   return BOTAN_FFI_VISIT(crl_obj, [=](const Botan::X509_CRL& crl) -> int {
      switch(value_type) {
         case BOTAN_X509_PEM_ENCODING:
            return botan_x509_object_view_value(crl, value_type, index, ctx, view);
 
         case BOTAN_X509_SERIAL_NUMBER:
         case BOTAN_X509_SUBJECT_DN_BITS:
         case BOTAN_X509_ISSUER_DN_BITS:
         case BOTAN_X509_SUBJECT_KEY_IDENTIFIER:
         case BOTAN_X509_AUTHORITY_KEY_IDENTIFIER:
         case BOTAN_X509_PUBLIC_KEY_PKCS8_BITS:
         case BOTAN_X509_TBS_DATA_BITS:
         case BOTAN_X509_SIGNATURE_SCHEME_BITS:
         case BOTAN_X509_SIGNATURE_BITS:
         case BOTAN_X509_DER_ENCODING:
         case BOTAN_X509_CRL_DISTRIBUTION_URLS:
         case BOTAN_X509_OCSP_RESPONDER_URLS:
         case BOTAN_X509_CA_ISSUERS_URLS:
            return BOTAN_FFI_ERROR_NO_VALUE;
      }
 
      return BOTAN_FFI_ERROR_BAD_PARAMETER;
   });
#else
   BOTAN_UNUSED(crl_obj, value_type, index, ctx, view);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References BOTAN_FFI_ERROR_BAD_PARAMETER, BOTAN_FFI_ERROR_NO_VALUE, BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_VISIT, BOTAN_UNUSED, BOTAN_X509_AUTHORITY_KEY_IDENTIFIER, BOTAN_X509_CA_ISSUERS_URLS, BOTAN_X509_CRL_DISTRIBUTION_URLS, BOTAN_X509_DER_ENCODING, BOTAN_X509_ISSUER_DN_BITS, BOTAN_X509_OCSP_RESPONDER_URLS, BOTAN_X509_PEM_ENCODING, BOTAN_X509_PUBLIC_KEY_PKCS8_BITS, BOTAN_X509_SERIAL_NUMBER, BOTAN_X509_SIGNATURE_BITS, BOTAN_X509_SIGNATURE_SCHEME_BITS, BOTAN_X509_SUBJECT_DN_BITS, BOTAN_X509_SUBJECT_KEY_IDENTIFIER, and BOTAN_X509_TBS_DATA_BITS.

Referenced by botan_x509_crl_view_string_values_count().

botan_x509_crl_view_string_values_count()

int botan_x509_crl_view_string_values_count	(	botan_x509_crl_t	crl_obj,
		botan_x509_value_type	value_type,
		size_t *	count )

Definition at line 1321 of file ffi_cert.cpp.

                                                                                                                       {
#if defined(BOTAN_HAS_X509_CERTIFICATES)
   return enumerator_count_values(count, [=](size_t index) {
      return botan_x509_crl_view_string_values(
         crl_obj, value_type, index, nullptr, [](auto, auto, auto) -> int { return BOTAN_FFI_SUCCESS; });
   });
#else
   BOTAN_UNUSED(crl_obj, value_type, count);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_SUCCESS, BOTAN_UNUSED, and botan_x509_crl_view_string_values().

botan_x509_general_name_destroy()

int botan_x509_general_name_destroy

(

botan_x509_general_name_t

alt_names

)

Definition at line 803 of file ffi_cert.cpp.

                                                                    {
#if defined(BOTAN_HAS_X509_CERTIFICATES)
   return BOTAN_FFI_CHECKED_DELETE(name);
#else
   BOTAN_UNUSED(name);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References BOTAN_FFI_CHECKED_DELETE, BOTAN_FFI_ERROR_NOT_IMPLEMENTED, and BOTAN_UNUSED.

botan_x509_general_name_get_type()

int botan_x509_general_name_get_type	(	botan_x509_general_name_t	name,
		unsigned int *	type )

Provides the contained type of the name and returns BOTAN_FFI_SUCCESS if that type is supported and may be retrieved via the view functions below. Otherwise BOTAN_FFI_ERROR_INVALID_OBJECT_STATE is returned.

Definition at line 733 of file ffi_cert.cpp.

                                                                                         {
#if defined(BOTAN_HAS_X509_CERTIFICATES)
   return BOTAN_FFI_VISIT(name, [=](const Botan::GeneralName& n) {
      if(Botan::any_null_pointers(type)) {
         return BOTAN_FFI_ERROR_NULL_POINTER;
      }
 
      const auto mapped_type = to_botan_x509_general_name_types(n.type_code());
      if(!mapped_type.has_value()) {
         return BOTAN_FFI_ERROR_INVALID_OBJECT_STATE;
      }
 
      *type = mapped_type.value();
      if(*type == BOTAN_X509_OTHER_NAME /* ... viewing of other-names not supported */) {
         return BOTAN_FFI_ERROR_INVALID_OBJECT_STATE;
      }
 
      return BOTAN_FFI_SUCCESS;
   });
#else
   BOTAN_UNUSED(name, type);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References Botan::any_null_pointers(), BOTAN_FFI_ERROR_INVALID_OBJECT_STATE, BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_SUCCESS, BOTAN_FFI_VISIT, BOTAN_UNUSED, BOTAN_X509_OTHER_NAME, and Botan::GeneralName::type_code().

botan_x509_general_name_view_binary_value()

int botan_x509_general_name_view_binary_value	(	botan_x509_general_name_t	name,
		botan_view_ctx	ctx,
		botan_view_bin_fn	view )

Views the name as a bit string or returns BOTAN_FFI_ERROR_INVALID_OBJECT_STATE if the contained GeneralName value cannot be represented as a binary string.

The types BOTAN_X509_DIRECTORY_NAME, BOTAN_X509_IP_ADDRESS may be viewed as "binary".

Definition at line 781 of file ffi_cert.cpp.

                                                                      {
#if defined(BOTAN_HAS_X509_CERTIFICATES)
   return BOTAN_FFI_VISIT(name, [=](const Botan::GeneralName& n) -> int {
      const auto type = to_botan_x509_general_name_types(n.type_code());
      if(!type) {
         return BOTAN_FFI_ERROR_INVALID_OBJECT_STATE;
      }
 
      if(type != BOTAN_X509_DIRECTORY_NAME && type != BOTAN_X509_IP_ADDRESS) {
         return BOTAN_FFI_ERROR_INVALID_OBJECT_STATE;
      }
 
      return invoke_view_callback(view, ctx, n.binary_name());
   });
#else
   BOTAN_UNUSED(name, ctx, view);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References Botan::GeneralName::binary_name(), BOTAN_FFI_ERROR_INVALID_OBJECT_STATE, BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_VISIT, BOTAN_UNUSED, BOTAN_X509_DIRECTORY_NAME, BOTAN_X509_IP_ADDRESS, Botan_FFI::invoke_view_callback(), and Botan::GeneralName::type_code().

botan_x509_general_name_view_string_value()

int botan_x509_general_name_view_string_value	(	botan_x509_general_name_t	name,
		botan_view_ctx	ctx,
		botan_view_str_fn	view )

Views the name as a string or returns BOTAN_FFI_ERROR_INVALID_OBJECT_STATE if the contained GeneralName value cannot be represented as a string.

The types BOTAN_X509_EMAIL_ADDRESS, BOTAN_X509_DNS_NAME, BOTAN_X509_URI, BOTAN_X509_IP_ADDRESS may be viewed as "string".

Definition at line 758 of file ffi_cert.cpp.

                                                                      {
#if defined(BOTAN_HAS_X509_CERTIFICATES)
   return BOTAN_FFI_VISIT(name, [=](const Botan::GeneralName& n) -> int {
      const auto type = to_botan_x509_general_name_types(n.type_code());
      if(!type) {
         return BOTAN_FFI_ERROR_INVALID_OBJECT_STATE;
      }
 
      if(type != BOTAN_X509_EMAIL_ADDRESS && type != BOTAN_X509_DNS_NAME && type != BOTAN_X509_URI &&
         type != BOTAN_X509_IP_ADDRESS) {
         return BOTAN_FFI_ERROR_INVALID_OBJECT_STATE;
      }
 
      return invoke_view_callback(view, ctx, n.name());
   });
#else
   BOTAN_UNUSED(name, ctx, view);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References BOTAN_FFI_ERROR_INVALID_OBJECT_STATE, BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_VISIT, BOTAN_UNUSED, BOTAN_X509_DNS_NAME, BOTAN_X509_EMAIL_ADDRESS, BOTAN_X509_IP_ADDRESS, BOTAN_X509_URI, Botan_FFI::invoke_view_callback(), Botan::GeneralName::name(), and Botan::GeneralName::type_code().

botan_x509_is_revoked()

int botan_x509_is_revoked	(	botan_x509_crl_t	crl,
		botan_x509_cert_t	cert )

Given a CRL and a certificate, check if the certificate is revoked on that particular CRL

Definition at line 1333 of file ffi_cert.cpp.

                                                                        {
#if defined(BOTAN_HAS_X509_CERTIFICATES)
   return BOTAN_FFI_VISIT(crl, [=](const auto& c) { return c.is_revoked(safe_get(cert)) ? 0 : -1; });
#else
   BOTAN_UNUSED(cert);
   BOTAN_UNUSED(crl);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_VISIT, BOTAN_UNUSED, and Botan_FFI::safe_get().

botan_xof_accepts_input()

int botan_xof_accepts_input

(

botan_xof_t

xof

)

Get the input/output state of this eXtendable Output Function Typically, XOFs don't accept input as soon as the first output bytes were requested.

Parameters

eXtendable Output Function

the object to read

Returns

1 iff the XOF is still accepting input bytes

Definition at line 61 of file ffi_xof.cpp.

                                                  {
   return BOTAN_FFI_VISIT(this_xof, [=](const auto& xof) { return xof.accepts_input() ? 1 : 0; });
}

References BOTAN_FFI_VISIT.

botan_xof_block_size()

int botan_xof_block_size	(	botan_xof_t	xof,
		size_t *	block_size )

Writes the block size of the eXtendable Output Function to *block_size

Parameters

eXtendable Output Function	XOF object
block_size	variable to hold the XOF's block size

Returns

0 on success, a negative value on failure

Definition at line 46 of file ffi_xof.cpp.

                                                            {
   if(Botan::any_null_pointers(out)) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
   return BOTAN_FFI_VISIT(this_xof, [=](const auto& xof) { *out = xof.block_size(); });
}

References Botan::any_null_pointers(), BOTAN_FFI_ERROR_NULL_POINTER, and BOTAN_FFI_VISIT.

botan_xof_clear()

int botan_xof_clear

(

botan_xof_t

xof

)

Reinitializes the state of the eXtendable Output Function.

Parameters

eXtendable Output Function

XOF object

Returns

0 on success, a negative value on failure

Definition at line 65 of file ffi_xof.cpp.

                                          {
   return BOTAN_FFI_VISIT(this_xof, [](auto& xof) { xof.clear(); });
}

References BOTAN_FFI_VISIT.

botan_xof_copy_state()

int botan_xof_copy_state	(	botan_xof_t *	dest,
		botan_xof_t	source )

Copy the state of an eXtendable Output Function

Parameters

dest	destination XOF object
source	source XOF object

Returns

0 on success, a negative value on failure

Definition at line 39 of file ffi_xof.cpp.

                                                                        {
   if(dest == nullptr) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
   return BOTAN_FFI_VISIT(this_xof, [=](const auto& src) { return ffi_new_object(dest, src.copy_state()); });
}

References BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_VISIT, and Botan_FFI::ffi_new_object().

botan_xof_destroy()

int botan_xof_destroy

(

botan_xof_t

xof

)

Frees all resources of the eXtendable Output Function object

Parameters

eXtendable Output Function

xof object

Returns

0 if success, error if invalid object handle

Definition at line 93 of file ffi_xof.cpp.

                                       {
   return BOTAN_FFI_CHECKED_DELETE(xof);
}

References BOTAN_FFI_CHECKED_DELETE.

botan_xof_init()

int botan_xof_init	(	botan_xof_t *	xof,
		const char *	xof_name,
		uint32_t	flags )

Initialize an eXtendable Output Function

Parameters

eXtendable Output Function	XOF object
xof_name	name of the XOF, e.g., "SHAKE-128"
flags	should be 0 in current API revision, all other uses are reserved and return BOTAN_FFI_ERROR_BAD_FLAG

Definition at line 19 of file ffi_xof.cpp.

                                                                                {
   return ffi_guard_thunk(__func__, [=]() -> int {
      if(Botan::any_null_pointers(this_xof, xof_name) || *xof_name == 0) {
         return BOTAN_FFI_ERROR_NULL_POINTER;
      }
      if(flags != 0) {
         return BOTAN_FFI_ERROR_BAD_FLAG;
      }
 
      auto xof = Botan::XOF::create(xof_name);
      if(xof == nullptr) {
         return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
      }
 
      ffi_new_object(this_xof, std::move(xof));
      return BOTAN_FFI_SUCCESS;
   });
}

References Botan::any_null_pointers(), BOTAN_FFI_ERROR_BAD_FLAG, BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_SUCCESS, Botan::XOF::create(), Botan_FFI::ffi_guard_thunk(), and Botan_FFI::ffi_new_object().

botan_xof_name()

int botan_xof_name	(	botan_xof_t	xof,
		char *	name,
		size_t *	name_len )

Get the name of this eXtendable Output Function

Parameters

eXtendable Output Function	the object to read
name	output buffer
name_len	on input, the length of buffer, on success the number of bytes written

Definition at line 53 of file ffi_xof.cpp.

                                                                       {
   if(Botan::any_null_pointers(name_len)) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
 
   return BOTAN_FFI_VISIT(this_xof, [=](const auto& xof) { return write_str_output(name, name_len, xof.name()); });
}

References Botan::any_null_pointers(), BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_VISIT, and Botan_FFI::write_str_output().

botan_xof_output()

int botan_xof_output	(	botan_xof_t	xof,
		uint8_t *	out,
		size_t	out_len )

Generate output bytes from the eXtendable Output Function

Parameters

eXtendable Output Function	XOF object
out	output buffer
out_len	number of bytes to write into the output buffer

Returns

0 on success, a negative value on failure

Definition at line 81 of file ffi_xof.cpp.

                                                                         {
   if(out_len == 0) {
      return 0;
   }
 
   if(Botan::any_null_pointers(out)) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
 
   return BOTAN_FFI_VISIT(this_xof, [=](auto& xof) { xof.output({out, out_len}); });
}

References Botan::any_null_pointers(), BOTAN_FFI_ERROR_NULL_POINTER, and BOTAN_FFI_VISIT.

botan_xof_update()

int botan_xof_update	(	botan_xof_t	xof,
		const uint8_t *	in,
		size_t	in_len )

Send more input to the eXtendable Output Function

Parameters

eXtendable Output Function	XOF object
in	input buffer
in_len	number of bytes to read from the input buffer

Returns

0 on success, a negative value on failure

Definition at line 69 of file ffi_xof.cpp.

                                                                             {
   if(in_len == 0) {
      return 0;
   }
 
   if(Botan::any_null_pointers(in)) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
 
   return BOTAN_FFI_VISIT(this_xof, [=](auto& xof) { xof.update({in, in_len}); });
}

References Botan::any_null_pointers(), BOTAN_FFI_ERROR_NULL_POINTER, and BOTAN_FFI_VISIT.

botan_zfec_decode()

int botan_zfec_decode	(	size_t	K,
		size_t	N,
		const size_t *	indexes,
		uint8_t *const *	inputs,
		size_t	shareSize,
		uint8_t **	outputs )

Decode some previously encoded shares using certain ZFEC parameters.

Parameters

K	the number of shares needed for recovery
N	the total number of shares
indexes	The index into the encoder's outputs for the corresponding element of the inputs array. Must be of length K.
inputs	K previously encoded shares to decode
shareSize	the length in bytes of each input
outputs	An out parameter pointing to a fully allocated array of size [K][shareSize]. For all k in range, a decoded block will written to the memory starting at outputs[k][0].

Returns

0 on success, negative on failure

Definition at line 35 of file ffi_zfec.cpp.

                                                                                                                 {
   if(Botan::any_null_pointers(indexes, inputs, outputs)) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
#if defined(BOTAN_HAS_ZFEC)
   return Botan_FFI::ffi_guard_thunk(__func__, [=]() -> int {
      std::map<size_t, const uint8_t*> shares;
      for(size_t k = 0; k < K; ++k) {
         shares.insert(std::pair<size_t, const uint8_t*>(indexes[k], inputs[k]));
      }
      Botan::ZFEC(K, N).decode_shares(
         shares, shareSize, [=](size_t index, const uint8_t block[], size_t blockSize) -> void {
            std::copy(block, block + blockSize, outputs[index]);
         });
      return BOTAN_FFI_SUCCESS;
   });
#else
   BOTAN_UNUSED(K, N, indexes, inputs, shareSize, outputs);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References Botan::any_null_pointers(), BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_SUCCESS, BOTAN_UNUSED, Botan::ZFEC::decode_shares(), and Botan_FFI::ffi_guard_thunk().

Referenced by botan_srp6_server_session_step1().

botan_zfec_encode()

int botan_zfec_encode	(	size_t	K,
		size_t	N,
		const uint8_t *	input,
		size_t	size,
		uint8_t **	outputs )

ZFEC Encode some bytes with certain ZFEC parameters.

Parameters

K	the number of shares needed for recovery
N	the number of shares generated
input	the data to FEC
size	the length in bytes of input, which must be a multiple of K
outputs	An out parameter pointing to a fully allocated array of size [N][size / K]. For all n in range, an encoded block will be written to the memory starting at outputs[n][0].

Returns

0 on success, negative on failure

Definition at line 18 of file ffi_zfec.cpp.

                                                                                                {
   if(Botan::any_null_pointers(input, outputs)) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
#if defined(BOTAN_HAS_ZFEC)
   return Botan_FFI::ffi_guard_thunk(__func__, [=]() -> int {
      Botan::ZFEC(K, N).encode(input, size, [=](size_t index, const uint8_t block[], size_t blockSize) -> void {
         std::copy(block, block + blockSize, outputs[index]);
      });
      return BOTAN_FFI_SUCCESS;
   });
#else
   BOTAN_UNUSED(K, N, input, size, outputs);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References Botan::any_null_pointers(), BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_SUCCESS, BOTAN_UNUSED, Botan::ZFEC::encode(), and Botan_FFI::ffi_guard_thunk().

Referenced by botan_srp6_server_session_step1().