Public Header. More...

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

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 20260303
#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_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_privkey_create (botan_privkey_t key, const char algo_name, botan_ec_group_t ec_group, botan_rng_t rng)
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_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_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 1440 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 641 of file ffi.h.

◆ BOTAN_CIPHER_INIT_FLAG_ENCRYPT

#define BOTAN_CIPHER_INIT_FLAG_ENCRYPT 0

Definition at line 640 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 639 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 734 of file ffi.h.

Referenced by botan_cipher_update().

◆ BOTAN_FFI_API_VERSION

#define BOTAN_FFI_API_VERSION 20260303

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 2852 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 1510 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 1511 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 1512 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 2067 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 1224 of file ffi.h.

◆ botan_block_cipher_t

typedef struct botan_block_cipher_struct* botan_block_cipher_t

Definition at line 937 of file ffi.h.

◆ botan_cipher_t

typedef struct botan_cipher_struct* botan_cipher_t

Definition at line 637 of file ffi.h.

◆ botan_ec_group_t

typedef struct botan_ec_group_struct* botan_ec_group_t

Definition at line 1273 of file ffi.h.

◆ botan_fpe_t

typedef struct botan_fpe_struct* botan_fpe_t

Format Preserving Encryption

Definition at line 2850 of file ffi.h.

◆ botan_hash_t

typedef struct botan_hash_struct* botan_hash_t

Definition at line 461 of file ffi.h.

◆ botan_hotp_t

typedef struct botan_hotp_struct* botan_hotp_t

HOTP

Definition at line 2778 of file ffi.h.

◆ botan_mac_t

typedef struct botan_mac_struct* botan_mac_t

Definition at line 541 of file ffi.h.

◆ botan_mp_t

typedef struct botan_mp_struct* botan_mp_t

Definition at line 1003 of file ffi.h.

◆ botan_pk_op_decrypt_t

typedef struct botan_pk_op_decrypt_struct* botan_pk_op_decrypt_t

Definition at line 2046 of file ffi.h.

◆ botan_pk_op_encrypt_t

typedef struct botan_pk_op_encrypt_struct* botan_pk_op_encrypt_t

Definition at line 2022 of file ffi.h.

◆ botan_pk_op_ka_t

typedef struct botan_pk_op_ka_struct* botan_pk_op_ka_t

Definition at line 2108 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 2167 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 2137 of file ffi.h.

◆ botan_pk_op_sign_t

typedef struct botan_pk_op_sign_struct* botan_pk_op_sign_t

Definition at line 2069 of file ffi.h.

◆ botan_pk_op_verify_t

typedef struct botan_pk_op_verify_struct* botan_pk_op_verify_t

Definition at line 2089 of file ffi.h.

◆ botan_privkey_t

typedef struct botan_privkey_struct* botan_privkey_t

Definition at line 1417 of file ffi.h.

◆ botan_pubkey_t

typedef struct botan_pubkey_struct* botan_pubkey_t

Definition at line 1650 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 2873 of file ffi.h.

◆ botan_totp_t

typedef struct botan_totp_struct* botan_totp_t

TOTP

Definition at line 2810 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 3041 of file ffi.h.

◆ botan_tpm2_ctx_t

typedef struct botan_tpm2_ctx_struct* botan_tpm2_ctx_t

TPM2 context

Definition at line 3031 of file ffi.h.

◆ botan_tpm2_session_t

typedef struct botan_tpm2_session_struct* botan_tpm2_session_t

TPM2 session

Definition at line 3036 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 2231 of file ffi.h.

◆ botan_x509_crl_entry_t

typedef struct botan_x509_crl_entry_struct* botan_x509_crl_entry_t

Definition at line 2546 of file ffi.h.

◆ botan_x509_crl_t

typedef struct botan_x509_crl_struct* botan_x509_crl_t

Definition at line 2545 of file ffi.h.

◆ botan_x509_general_name_t

typedef struct botan_x509_general_name_struct* botan_x509_general_name_t

Definition at line 2414 of file ffi.h.

◆ botan_xof_t

typedef struct botan_xof_struct* botan_xof_t

Definition at line 383 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 2373 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 2577 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 2421 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 2246 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 350 of file ffi.cpp.

                                                                                              {
   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::base64_decode(), Botan::base64_decode_max_output(), BOTAN_FFI_ERROR_INSUFFICIENT_BUFFER_SPACE, 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 343 of file ffi.cpp.

                                                                                   {
   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::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
rng	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 157 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
hash	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 189 of file ffi_kdf.cpp.

                                                              {
#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_ERROR_NOT_IMPLEMENTED, 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 120 of file ffi_cipher.cpp.

                                              {
   return BOTAN_FFI_VISIT(cipher, [](auto& c) { 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 116 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 304 of file ffi_cipher.cpp.

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

References 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 312 of file ffi_cipher.cpp.

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

References 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 143 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 316 of file ffi_cipher.cpp.

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

References 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 308 of file ffi_cipher.cpp.

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

References 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 {
      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_CIPHER_INIT_FLAG_ENCRYPT, BOTAN_CIPHER_INIT_FLAG_MASK_DIRECTION, BOTAN_FFI_ERROR_NOT_IMPLEMENTED, 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 320 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 328 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 128 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 136 of file ffi_cipher.cpp.

                                                                                                                   {
   return BOTAN_FFI_VISIT(cipher, [=](const auto& c) {
      *out_minimum_keylength = c.key_spec().minimum_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 324 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 124 of file ffi_cipher.cpp.

                                              {
   return BOTAN_FFI_VISIT(cipher, [](auto& c) { 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 290 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 160 of file ffi_cipher.cpp.

                                                                                    {
   return BOTAN_FFI_VISIT(cipher, [=](auto& c) { c.set_key(key, key_len); });
}

References 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 164 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 172 of file ffi_cipher.cpp.

                                                {
   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_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_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 300 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 313 of file ffi.cpp.

                                                                                {
   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::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 20 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 189 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 71 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 110 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 97 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 50 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 84 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 166 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 170 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 138 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 174 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 179 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 184 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 162 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 24 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 36 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 123 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 127 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 132 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_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
rng	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_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.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

hash	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

hash	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.

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

References 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

hash	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

hash	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

hash	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

hash	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 83 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

hash	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

hash	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 336 of file ffi.cpp.

                                                                                        {
   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::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 328 of file ffi.cpp.

                                                                               {
   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_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 130 of file ffi_kdf.cpp.

                                {
   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_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 98 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 87 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

mac	mac object

Returns: 0 on success, a negative value on failure

Definition at line 52 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

mac	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

mac	mac object
out	output buffer

Returns: 0 on success, a negative value on failure

Definition at line 60 of file ffi_mac.cpp.

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

References 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

mac	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 68 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

mac	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

mac	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 64 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

mac	mac object
output_length	output buffer to hold the MAC output length

Returns: 0 on success, a negative value on failure

Definition at line 48 of file ffi_mac.cpp.

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

References 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

mac	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.

                                                                           {
   return BOTAN_FFI_VISIT(mac, [=](auto& m) { m.set_key(key, key_len); });
}

References 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

mac	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 44 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

mac	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 56 of file ffi_mac.cpp.

                                                                      {
   return BOTAN_FFI_VISIT(mac, [=](auto& m) { m.update(buf, len); });
}

References 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 1480 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 1492 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 144 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 164 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 278 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 218 of file ffi_mp.cpp.

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

References 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 140 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 194 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 202 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.

                                                                          {
   return BOTAN_FFI_VISIT(mp, [=](auto& bn) { bn._assign_from_bytes({bin, bin_len}); });
}

References 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 262 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 270 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 214 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.is_negative() ? 1 : 0; });
}

References BOTAN_FFI_VISIT.

◆ botan_mp_is_odd()

int botan_mp_is_odd ( botan_mp_t mp )

Definition at line 210 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.is_positive() ? 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 266 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 206 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 232 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 240 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 246 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 184 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 282 of file ffi_mp.cpp.

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

References 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 286 of file ffi_mp.cpp.

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

References 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 227 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 253 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 257 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 236 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 274 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 154 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 174 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 222 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 122 of file ffi_mp.cpp.

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

References 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 80 of file ffi_mp.cpp.

                                                    {
   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, 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 98 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 133 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 126 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 91 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 110 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 54 of file ffi_keywrap.cpp.

                                       {
#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_ERROR_NOT_IMPLEMENTED, 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 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_ERROR_NOT_IMPLEMENTED, 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 22 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 32 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 445 of file ffi_pkey.cpp.

                                                                                      {
#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_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 144 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 160 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.
rng	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 597 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 637 of file ffi_pkey_algs.cpp.

                                                                                                    {
   if(key_obj == nullptr || param_str == nullptr) {
      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_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 438 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 1475 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 227 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 112 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 418 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 874 of file ffi_pkey_algs.cpp.

                                                                               {
#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_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 948 of file ffi_pkey_algs.cpp.

                                                                             {
#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_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 194 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 221 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 308 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 231 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 136 of file ffi_pkey.cpp.

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

References BOTAN_FFI_SUCCESS, 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 215 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
rng	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
rng	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);
 
   *key = nullptr;
 
   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_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 1413 of file ffi_pkey_algs.cpp.

                                                               {
#if defined(BOTAN_HAS_CLASSICMCELIECE)
   if(key == nullptr || privkey == nullptr || cmce_mode == nullptr) {
      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_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 601 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 382 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 703 of file ffi_pkey_algs.cpp.

                                                                                                   {
#if defined(BOTAN_HAS_ECDH)
   if(key == nullptr || curve_name == nullptr) {
      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_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 513 of file ffi_pkey_algs.cpp.

                                                                                                    {
#if defined(BOTAN_HAS_ECDSA)
   if(key == nullptr || curve_name == nullptr) {
      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_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] )

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: Ed25519

Definition at line 840 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 916 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 1371 of file ffi_pkey_algs.cpp.

                                                                                                                       {
#if defined(BOTAN_HAS_FRODOKEM)
   if(key == nullptr || privkey == nullptr || frodo_mode == nullptr) {
      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_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 1123 of file ffi_pkey_algs.cpp.

                                                                                            {
#if defined(BOTAN_HAS_KYBER)
   if(key == nullptr) {
      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_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 1271 of file ffi_pkey_algs.cpp.

                                                                                                                     {
#if defined(BOTAN_HAS_ML_DSA)
   if(key == nullptr || privkey == nullptr || mldsa_mode == nullptr) {
      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_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 1221 of file ffi_pkey_algs.cpp.

                                                                                                                     {
#if defined(BOTAN_HAS_ML_KEM)
   if(key == nullptr || privkey == nullptr || mlkem_mode == nullptr) {
      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_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 237 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 254 of file ffi_pkey_algs.cpp.

                                                                                         {
#if defined(BOTAN_HAS_RSA)
   if(key == nullptr || bits == nullptr) {
      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_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 1321 of file ffi_pkey_algs.cpp.

                                                                                                                       {
#if defined(BOTAN_HAS_SLH_DSA_WITH_SHA2) || defined(BOTAN_HAS_SLH_DSA_WITH_SHAKE)
   if(key == nullptr || privkey == nullptr || slhdsa_mode == nullptr) {
      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_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 805 of file ffi_pkey_algs.cpp.

                                                                                                  {
#if defined(BOTAN_HAS_SM2)
   if(key == nullptr || curve_name == nullptr) {
      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_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 834 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 984 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 1054 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 391 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 419 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 322 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 318 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 314 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 306 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 334 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 310 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 404 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 206 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 328 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 256 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 353 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 282 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 1187 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 211 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 216 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 1016 of file ffi_pkey_algs.cpp.

                                                                              {
#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_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 1086 of file ffi_pkey_algs.cpp.

                                                                            {
#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_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 148 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 152 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 132 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 430 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 422 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 426 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 434 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 444 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 894 of file ffi_pkey_algs.cpp.

                                                                            {
#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_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 965 of file ffi_pkey_algs.cpp.

                                                                          {
#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_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 434 of file ffi_pkey.cpp.

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

References 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 167 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 438 of file ffi_pkey.cpp.

                                                                                                      {
   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_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 205 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 116 of file ffi_pkey.cpp.

                                                                                  {
   *key = nullptr;
 
   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_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 1435 of file ffi_pkey_algs.cpp.

                                                              {
#if defined(BOTAN_HAS_CLASSICMCELIECE)
   if(key == nullptr || pubkey == nullptr || cmce_mode == nullptr) {
      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_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 400 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 656 of file ffi_pkey_algs.cpp.

                                                   {
#if defined(BOTAN_HAS_ECDH)
   if(key == nullptr || curve_name == nullptr) {
      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_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 680 of file ffi_pkey_algs.cpp.

                                                                                                                    {
#if defined(BOTAN_HAS_ECDH)
   if(key == nullptr || sec1 == nullptr || curve_name == nullptr) {
      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_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 464 of file ffi_pkey_algs.cpp.

                                                    {
#if defined(BOTAN_HAS_ECDSA)
   if(key == nullptr || curve_name == nullptr) {
      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_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 490 of file ffi_pkey_algs.cpp.

                                                                                                                     {
#if defined(BOTAN_HAS_ECDSA)
   if(key == nullptr || sec1 == nullptr || curve_name == nullptr) {
      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_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 857 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 932 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 1390 of file ffi_pkey_algs.cpp.

                                                                                                                    {
#if defined(BOTAN_HAS_FRODOKEM)
   if(key == nullptr || pubkey == nullptr || frodo_mode == nullptr) {
      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_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 1156 of file ffi_pkey_algs.cpp.

                                                                                         {
#if defined(BOTAN_HAS_KYBER)
   if(key == nullptr) {
      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()) {
      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_FFI_ERROR_BAD_PARAMETER, BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_UNUSED, 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 1294 of file ffi_pkey_algs.cpp.

                                                                                                                  {
#if defined(BOTAN_HAS_ML_DSA)
   if(key == nullptr || pubkey == nullptr || mldsa_mode == nullptr) {
      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_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 1244 of file ffi_pkey_algs.cpp.

                                                                                                                  {
#if defined(BOTAN_HAS_ML_KEM)
   if(key == nullptr || pubkey == nullptr || mlkem_mode == nullptr) {
      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_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 272 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 288 of file ffi_pkey_algs.cpp.

                                                                                       {
#if defined(BOTAN_HAS_RSA)
   if(key == nullptr || bits == nullptr) {
      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_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 1344 of file ffi_pkey_algs.cpp.

                                                                                                                    {
#if defined(BOTAN_HAS_SLH_DSA_WITH_SHA2) || defined(BOTAN_HAS_SLH_DSA_WITH_SHAKE)
   if(key == nullptr || pubkey == nullptr || slhdsa_mode == nullptr) {
      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_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 758 of file ffi_pkey_algs.cpp.

                                                  {
#if defined(BOTAN_HAS_SM2)
   if(key == nullptr || curve_name == nullptr) {
      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_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 827 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 782 of file ffi_pkey_algs.cpp.

                                                                                                                   {
#if defined(BOTAN_HAS_SM2)
   if(key == nullptr || sec1 == nullptr || curve_name == nullptr) {
      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_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 1000 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 1070 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 378 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 326 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 330 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 725 of file ffi_pkey_algs.cpp.

                                                                                                       {
   if(out == nullptr || out_len == nullptr || ident == nullptr || hash_algo == nullptr || key == nullptr) {
      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_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 179 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 1457 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 1202 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 184 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 189 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 1036 of file ffi_pkey_algs.cpp.

                                                                           {
#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_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 1103 of file ffi_pkey_algs.cpp.

                                                                         {
#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_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 53 of file ffi_kdf.cpp.

                                   {
   if(algo == nullptr || password == 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 86 of file ffi_kdf.cpp.

                                         {
   if(algo == nullptr || password == 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

rng	rng object
entropy	the data to add
entropy_len	length of entropy buffer

Returns: 0 on success, a negative value on failure

Definition at line 178 of file ffi_rng.cpp.

                                                                             {
   return BOTAN_FFI_VISIT(rng, [=](auto& r) { r.add_entropy(input, len); });
}

References BOTAN_FFI_VISIT.

◆ botan_rng_destroy()

int botan_rng_destroy ( botan_rng_t rng )

Frees all resources of the random number generator object

Parameters

rng	rng object

Returns: 0 if success, error if invalid object handle

Definition at line 159 of file ffi_rng.cpp.

                                       {
   return BOTAN_FFI_CHECKED_DELETE(rng);
}

References BOTAN_FFI_CHECKED_DELETE.

◆ 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

rng	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 163 of file ffi_rng.cpp.

                                                                 {
   return BOTAN_FFI_VISIT(rng, [=](auto& r) { r.randomize(out, out_len); });
}

References 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

rng	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 33 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 76 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 : 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_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

rng	rng object
bits	number of bits to reseed with

Returns: 0 on success, a negative value on failure

Definition at line 174 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

rng	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 182 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 319 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 323 of file ffi.cpp.

                                             {
   Botan::secure_scrub_memory(mem, bytes);
   return BOTAN_FFI_SUCCESS;
}

References 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 146 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_id	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 150 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_id	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 120 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 46 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

srp6	SRP-6 server session object

Returns: 0 if success, error if invalid object handle

Definition at line 42 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

srp6	SRP-6 server session object

Definition at line 32 of file ffi_srp6.cpp.

                                                                      {
#if defined(BOTAN_HAS_SRP6)
   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_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

srp6	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_id	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

srp6	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 99 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 167 of file ffi_rng.cpp.

                                                       {
   return ffi_guard_thunk(__func__, [=]() -> int {
      Botan::system_rng().randomize(out, out_len);
      return BOTAN_FFI_SUCCESS;
   });
}

References 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
rng	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
rng	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 309 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 297 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 301 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 305 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 293 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 584 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 569 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 554 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 593 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 186 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 824 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 846 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 678 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 665 of file ffi_cert.cpp.

                                                                                                              {
#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_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 473 of file ffi_cert.cpp.

                                                                                          {
#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_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 491 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 435 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 455 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 696 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 640 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 507 of file ffi_cert.cpp.

                                                                                          {
#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_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 525 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 687 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 612 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 602 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 937 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 426 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 898 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 923 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 204 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 169 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 631 of file ffi_cert.cpp.

                                                                                  {
#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_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 622 of file ffi_cert.cpp.

                                                                                   {
#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_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 789 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 811 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 649 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 859 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 884 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 541 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 1017 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 950 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 1420 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 545 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 278 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 333 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 700 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 345 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 414 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
rng	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 1100 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 1190 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 1320 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 1340 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 1126 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 1353 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 1362 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 1404 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 1378 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 1394 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 1047 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 1030 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 1079 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 1064 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
rng	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 1141 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 1181 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 1199 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 1251 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 1263 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 1298 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 780 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 710 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 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_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 735 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 1310 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

xof	the object to read

Returns: 1 iff the XOF is still accepting input bytes

Definition at line 58 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

xof	XOF object
block_size	variable to hold the XOF's block size

Returns: 0 on success, a negative value on failure

Definition at line 43 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

xof	XOF object

Returns: 0 on success, a negative value on failure

Definition at line 62 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.

                                                                        {
   return BOTAN_FFI_VISIT(this_xof, [=](const auto& src) { return ffi_new_object(dest, src.copy_state()); });
}

References 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

xof	xof object

Returns: 0 if success, error if invalid object handle

Definition at line 90 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

xof	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

xof	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 50 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

xof	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 78 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

xof	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 66 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 32 of file ffi_zfec.cpp.

                                                                                                                 {
#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_FFI_ERROR_NOT_IMPLEMENTED, 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 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_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_SUCCESS, BOTAN_UNUSED, Botan::ZFEC::encode(), and Botan_FFI::ffi_guard_thunk().

Referenced by botan_srp6_server_session_step1().

Macros

Typedefs

Enumerations

Functions

Detailed Description

Macro Definition Documentation

◆ BOTAN_CHECK_KEY_EXPENSIVE_TESTS

◆ BOTAN_CIPHER_INIT_FLAG_DECRYPT

◆ BOTAN_CIPHER_INIT_FLAG_ENCRYPT

◆ BOTAN_CIPHER_INIT_FLAG_MASK_DIRECTION

◆ BOTAN_CIPHER_UPDATE_FLAG_FINAL

◆ BOTAN_FFI_API_VERSION

◆ BOTAN_FFI_DEPRECATED

◆ BOTAN_FFI_EXPORT

◆ BOTAN_FFI_HEX_LOWER_CASE

◆ BOTAN_FPE_FLAG_FE1_COMPAT_MODE

◆ BOTAN_PRIVKEY_EXPORT_FLAG_DER

◆ BOTAN_PRIVKEY_EXPORT_FLAG_PEM

◆ BOTAN_PRIVKEY_EXPORT_FLAG_RAW

◆ BOTAN_PUBKEY_DER_FORMAT_SIGNATURE

Typedef Documentation

◆ botan_asn1_oid_t

◆ botan_block_cipher_t

◆ botan_cipher_t

◆ botan_ec_group_t

◆ botan_fpe_t

◆ botan_hash_t

◆ botan_hotp_t

◆ botan_mac_t

◆ botan_mp_t

◆ botan_pk_op_decrypt_t

◆ botan_pk_op_encrypt_t

◆ botan_pk_op_ka_t

◆ botan_pk_op_kem_decrypt_t

◆ botan_pk_op_kem_encrypt_t

◆ botan_pk_op_sign_t

◆ botan_pk_op_verify_t

◆ botan_privkey_t

◆ botan_pubkey_t

◆ botan_rng_t

◆ botan_srp6_server_session_t

◆ botan_totp_t

◆ botan_tpm2_crypto_backend_state_t

◆ botan_tpm2_ctx_t

◆ botan_tpm2_session_t

◆ botan_view_bin_fn

◆ botan_view_ctx

◆ botan_view_str_fn

◆ botan_x509_cert_t

◆ botan_x509_crl_entry_t

◆ botan_x509_crl_t

◆ botan_x509_general_name_t

◆ botan_xof_t

Enumeration Type Documentation

◆ BOTAN_FFI_ERROR

◆ botan_x509_cert_key_constraints

◆ botan_x509_crl_reason_code

◆ botan_x509_general_name_types

◆ botan_x509_value_type

Function Documentation

◆ botan_base64_decode()

◆ botan_base64_encode()

◆ botan_bcrypt_generate()

◆ botan_bcrypt_is_valid()

◆ botan_block_cipher_block_size()

◆ botan_block_cipher_clear()

◆ botan_block_cipher_decrypt_blocks()

◆ botan_block_cipher_destroy()

◆ botan_block_cipher_encrypt_blocks()

◆ botan_block_cipher_get_keyspec()

◆ botan_block_cipher_init()

◆ botan_block_cipher_name()

◆ botan_block_cipher_set_key()

◆ botan_cipher_clear()

◆ botan_cipher_destroy()

◆ botan_cipher_get_default_nonce_length()

◆ botan_cipher_get_ideal_update_granularity()

◆ botan_cipher_get_keyspec()

◆ botan_cipher_get_tag_length()

◆ botan_cipher_get_update_granularity()