Botan 3.4.0
Crypto and TLS for C&
Macros | Typedefs | Enumerations | Functions
ffi.h File Reference
Foreign Function Interface

Public Header. More...

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

Go to the source code of this file.

Macros

#define BOTAN_CHECK_KEY_EXPENSIVE_TESTS   1
 
#define BOTAN_CIPHER_INIT_FLAG_DECRYPT   1
 
#define BOTAN_CIPHER_INIT_FLAG_ENCRYPT   0
 
#define BOTAN_CIPHER_INIT_FLAG_MASK_DIRECTION   1
 
#define BOTAN_CIPHER_UPDATE_FLAG_FINAL   (1U << 0)
 
#define BOTAN_FFI_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_PUBKEY_DER_FORMAT_SIGNATURE   1
 

Typedefs

typedef struct botan_block_cipher_struct * botan_block_cipher_t
 
typedef struct botan_cipher_struct * botan_cipher_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 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_struct * botan_x509_crl_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_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_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_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
}
 

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, 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, 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)
 
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)
 
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 base, char *out, size_t *out_len)
 
int botan_mp_to_uint32 (botan_mp_t mp, uint32_t *val)
 
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_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_dsa (botan_privkey_t *key, botan_rng_t rng, size_t pbits, size_t qbits)
 
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_elgamal (botan_privkey_t *key, botan_rng_t rng, size_t pbits, size_t qbits)
 
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_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_elgamal (botan_privkey_t *key, botan_mp_t p, botan_mp_t g, botan_mp_t x)
 
int botan_privkey_load_kyber (botan_privkey_t *key, const uint8_t privkey[], size_t key_len)
 
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_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_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_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_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_dh (botan_pubkey_t *key, botan_mp_t p, botan_mp_t g, botan_mp_t y)
 
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_ecdsa (botan_pubkey_t *key, botan_mp_t public_x, botan_mp_t public_y, 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_elgamal (botan_pubkey_t *key, botan_mp_t p, botan_mp_t g, botan_mp_t y)
 
int botan_pubkey_load_kyber (botan_pubkey_t *key, const uint8_t pubkey[], size_t key_len)
 
int botan_pubkey_load_rsa (botan_pubkey_t *key, botan_mp_t n, botan_mp_t e)
 
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_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_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_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)
 
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_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_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_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_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_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_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_public_key_bits (botan_x509_cert_t cert, botan_view_ctx ctx, botan_view_bin_fn view)
 
int botan_x509_crl_destroy (botan_x509_crl_t crl)
 
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_is_revoked (botan_x509_crl_t crl, botan_x509_cert_t cert)
 
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 1079 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 528 of file ffi.h.

◆ BOTAN_CIPHER_INIT_FLAG_ENCRYPT

#define BOTAN_CIPHER_INIT_FLAG_ENCRYPT   0

Definition at line 527 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 526 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 621 of file ffi.h.

Referenced by botan_cipher_update().

◆ BOTAN_FFI_DEPRECATED

#define BOTAN_FFI_DEPRECATED ( msg)

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

◆ BOTAN_FFI_HEX_LOWER_CASE

#define BOTAN_FFI_HEX_LOWER_CASE   1

Definition at line 225 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 1998 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 1149 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 1150 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_PUBKEY_DER_FORMAT_SIGNATURE

#define BOTAN_PUBKEY_DER_FORMAT_SIGNATURE   1

Definition at line 1585 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_block_cipher_t

typedef struct botan_block_cipher_struct* botan_block_cipher_t

Definition at line 803 of file ffi.h.

◆ botan_cipher_t

typedef struct botan_cipher_struct* botan_cipher_t

Definition at line 524 of file ffi.h.

◆ botan_fpe_t

typedef struct botan_fpe_struct* botan_fpe_t

Format Preserving Encryption

Definition at line 1996 of file ffi.h.

◆ botan_hash_t

typedef struct botan_hash_struct* botan_hash_t

Definition at line 348 of file ffi.h.

◆ botan_hotp_t

typedef struct botan_hotp_struct* botan_hotp_t

HOTP

Definition at line 1924 of file ffi.h.

◆ botan_mac_t

typedef struct botan_mac_struct* botan_mac_t

Definition at line 428 of file ffi.h.

◆ botan_mp_t

typedef struct botan_mp_struct* botan_mp_t

Definition at line 869 of file ffi.h.

◆ botan_pk_op_decrypt_t

typedef struct botan_pk_op_decrypt_struct* botan_pk_op_decrypt_t

Definition at line 1564 of file ffi.h.

◆ botan_pk_op_encrypt_t

typedef struct botan_pk_op_encrypt_struct* botan_pk_op_encrypt_t

Definition at line 1540 of file ffi.h.

◆ botan_pk_op_ka_t

typedef struct botan_pk_op_ka_struct* botan_pk_op_ka_t

Definition at line 1626 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 1685 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 1655 of file ffi.h.

◆ botan_pk_op_sign_t

typedef struct botan_pk_op_sign_struct* botan_pk_op_sign_t

Definition at line 1587 of file ffi.h.

◆ botan_pk_op_verify_t

typedef struct botan_pk_op_verify_struct* botan_pk_op_verify_t

Definition at line 1607 of file ffi.h.

◆ botan_privkey_t

typedef struct botan_privkey_struct* botan_privkey_t

Definition at line 1066 of file ffi.h.

◆ botan_pubkey_t

typedef struct botan_pubkey_struct* botan_pubkey_t

Definition at line 1280 of file ffi.h.

◆ botan_rng_t

typedef struct botan_rng_struct* botan_rng_t

RNG type

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

◆ botan_totp_t

typedef struct botan_totp_struct* botan_totp_t

TOTP

Definition at line 1956 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_ctxsome application context
datathe binary data
lenthe length of data in bytes

Definition at line 143 of file ffi.h.

◆ botan_view_ctx

typedef void* botan_view_ctx

Definition at line 134 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_ctxsome application context
strthe null terminated string
lenthe length of string including the null terminator

Definition at line 152 of file ffi.h.

◆ botan_x509_cert_t

typedef struct botan_x509_cert_struct* botan_x509_cert_t

Definition at line 1749 of file ffi.h.

◆ botan_x509_crl_t

typedef struct botan_x509_crl_struct* botan_x509_crl_t

Definition at line 1847 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_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_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_UNKNOWN_ERROR 

Definition at line 102 of file ffi.h.

102 {
103 BOTAN_FFI_SUCCESS = 0,
104 BOTAN_FFI_INVALID_VERIFIER = 1,
105
106 BOTAN_FFI_ERROR_INVALID_INPUT = -1,
107 BOTAN_FFI_ERROR_BAD_MAC = -2,
108
109 BOTAN_FFI_ERROR_INSUFFICIENT_BUFFER_SPACE = -10,
110 BOTAN_FFI_ERROR_STRING_CONVERSION_ERROR = -11,
111
112 BOTAN_FFI_ERROR_EXCEPTION_THROWN = -20,
113 BOTAN_FFI_ERROR_OUT_OF_MEMORY = -21,
114 BOTAN_FFI_ERROR_SYSTEM_ERROR = -22,
115 BOTAN_FFI_ERROR_INTERNAL_ERROR = -23,
116
117 BOTAN_FFI_ERROR_BAD_FLAG = -30,
118 BOTAN_FFI_ERROR_NULL_POINTER = -31,
119 BOTAN_FFI_ERROR_BAD_PARAMETER = -32,
120 BOTAN_FFI_ERROR_KEY_NOT_SET = -33,
121 BOTAN_FFI_ERROR_INVALID_KEY_LENGTH = -34,
122 BOTAN_FFI_ERROR_INVALID_OBJECT_STATE = -35,
123
124 BOTAN_FFI_ERROR_NOT_IMPLEMENTED = -40,
125 BOTAN_FFI_ERROR_INVALID_OBJECT = -50,
126
127 BOTAN_FFI_ERROR_TLS_ERROR = -75,
128 BOTAN_FFI_ERROR_HTTP_ERROR = -76,
129 BOTAN_FFI_ERROR_ROUGHTIME_ERROR = -77,
130
131 BOTAN_FFI_ERROR_UNKNOWN_ERROR = -100,
132};
BOTAN_FFI_ERROR_NOT_IMPLEMENTED
@ BOTAN_FFI_ERROR_NOT_IMPLEMENTED
Definition ffi.h:124
BOTAN_FFI_ERROR_INVALID_KEY_LENGTH
@ BOTAN_FFI_ERROR_INVALID_KEY_LENGTH
Definition ffi.h:121
BOTAN_FFI_ERROR_KEY_NOT_SET
@ BOTAN_FFI_ERROR_KEY_NOT_SET
Definition ffi.h:120
BOTAN_FFI_ERROR_TLS_ERROR
@ BOTAN_FFI_ERROR_TLS_ERROR
Definition ffi.h:127
BOTAN_FFI_ERROR_EXCEPTION_THROWN
@ BOTAN_FFI_ERROR_EXCEPTION_THROWN
Definition ffi.h:112
BOTAN_FFI_ERROR_OUT_OF_MEMORY
@ BOTAN_FFI_ERROR_OUT_OF_MEMORY
Definition ffi.h:113
BOTAN_FFI_ERROR_INTERNAL_ERROR
@ BOTAN_FFI_ERROR_INTERNAL_ERROR
Definition ffi.h:115
BOTAN_FFI_INVALID_VERIFIER
@ BOTAN_FFI_INVALID_VERIFIER
Definition ffi.h:104
BOTAN_FFI_ERROR_INVALID_OBJECT
@ BOTAN_FFI_ERROR_INVALID_OBJECT
Definition ffi.h:125
BOTAN_FFI_ERROR_UNKNOWN_ERROR
@ BOTAN_FFI_ERROR_UNKNOWN_ERROR
Definition ffi.h:131
BOTAN_FFI_ERROR_HTTP_ERROR
@ BOTAN_FFI_ERROR_HTTP_ERROR
Definition ffi.h:128
BOTAN_FFI_ERROR_BAD_FLAG
@ BOTAN_FFI_ERROR_BAD_FLAG
Definition ffi.h:117
BOTAN_FFI_ERROR_INVALID_INPUT
@ BOTAN_FFI_ERROR_INVALID_INPUT
Definition ffi.h:106
BOTAN_FFI_ERROR_STRING_CONVERSION_ERROR
@ BOTAN_FFI_ERROR_STRING_CONVERSION_ERROR
Definition ffi.h:110
BOTAN_FFI_ERROR_NULL_POINTER
@ BOTAN_FFI_ERROR_NULL_POINTER
Definition ffi.h:118
BOTAN_FFI_SUCCESS
@ BOTAN_FFI_SUCCESS
Definition ffi.h:103
BOTAN_FFI_ERROR_SYSTEM_ERROR
@ BOTAN_FFI_ERROR_SYSTEM_ERROR
Definition ffi.h:114
BOTAN_FFI_ERROR_ROUGHTIME_ERROR
@ BOTAN_FFI_ERROR_ROUGHTIME_ERROR
Definition ffi.h:129
BOTAN_FFI_ERROR_INVALID_OBJECT_STATE
@ BOTAN_FFI_ERROR_INVALID_OBJECT_STATE
Definition ffi.h:122
BOTAN_FFI_ERROR_INSUFFICIENT_BUFFER_SPACE
@ BOTAN_FFI_ERROR_INSUFFICIENT_BUFFER_SPACE
Definition ffi.h:109
BOTAN_FFI_ERROR_BAD_MAC
@ BOTAN_FFI_ERROR_BAD_MAC
Definition ffi.h:107
BOTAN_FFI_ERROR_BAD_PARAMETER
@ BOTAN_FFI_ERROR_BAD_PARAMETER
Definition ffi.h:119

◆ 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 1796 of file ffi.h.

1796 {
1797 NO_CONSTRAINTS = 0,
1798 DIGITAL_SIGNATURE = 32768,
1799 NON_REPUDIATION = 16384,
1800 KEY_ENCIPHERMENT = 8192,
1801 DATA_ENCIPHERMENT = 4096,
1802 KEY_AGREEMENT = 2048,
1803 KEY_CERT_SIGN = 1024,
1804 CRL_SIGN = 512,
1805 ENCIPHER_ONLY = 256,
1806 DECIPHER_ONLY = 128
1807};
KEY_ENCIPHERMENT
@ KEY_ENCIPHERMENT
Definition ffi.h:1800
NO_CONSTRAINTS
@ NO_CONSTRAINTS
Definition ffi.h:1797
CRL_SIGN
@ CRL_SIGN
Definition ffi.h:1804
DIGITAL_SIGNATURE
@ DIGITAL_SIGNATURE
Definition ffi.h:1798
KEY_AGREEMENT
@ KEY_AGREEMENT
Definition ffi.h:1802
DATA_ENCIPHERMENT
@ DATA_ENCIPHERMENT
Definition ffi.h:1801
KEY_CERT_SIGN
@ KEY_CERT_SIGN
Definition ffi.h:1803
ENCIPHER_ONLY
@ ENCIPHER_ONLY
Definition ffi.h:1805
NON_REPUDIATION
@ NON_REPUDIATION
Definition ffi.h:1799
DECIPHER_ONLY
@ DECIPHER_ONLY
Definition ffi.h:1806

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

335 {
336 return ffi_guard_thunk(__func__, [=]() -> int {
337 if(*out_len < Botan::base64_decode_max_output(in_len)) {
338 *out_len = Botan::base64_decode_max_output(in_len);
339 return BOTAN_FFI_ERROR_INSUFFICIENT_BUFFER_SPACE;
340 }
341
342 *out_len = Botan::base64_decode(out, std::string(base64_str, in_len));
343 return BOTAN_FFI_SUCCESS;
344 });
345}
Botan_FFI::ffi_guard_thunk
int ffi_guard_thunk(const char *func_name, const std::function< int()> &thunk)
Definition ffi.cpp:116
Botan::base64_decode
size_t base64_decode(uint8_t out[], const char in[], size_t input_length, size_t &input_consumed, bool final_inputs, bool ignore_ws)
Definition base64.cpp:154
Botan::base64_decode_max_output
size_t base64_decode_max_output(size_t input_length)
Definition base64.cpp:186

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

Definition at line 328 of file ffi.cpp.

328 {
329 return ffi_guard_thunk(__func__, [=]() -> int {
330 const std::string base64 = Botan::base64_encode(in, len);
331 return Botan_FFI::write_str_output(out, out_len, base64);
332 });
333}
Botan_FFI::write_str_output
int write_str_output(uint8_t out[], size_t *out_len, std::string_view str)
Definition ffi_util.h:205
Botan::base64_encode
size_t base64_encode(char out[], const uint8_t in[], size_t input_length, size_t &input_consumed, bool final_inputs)
Definition base64.cpp:146

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
outbuffer holding the password hash, should be of length 64 bytes
out_lenthe desired output length in bytes
passwordthe password
rnga random number generator
work_factorhow much work to do to slow down guessing attacks
flagsshould 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$...

Definition at line 157 of file ffi_kdf.cpp.

158 {
159#if defined(BOTAN_HAS_BCRYPT)
160 return ffi_guard_thunk(__func__, [=]() -> int {
161 if(out == nullptr || out_len == nullptr || pass == nullptr) {
162 return BOTAN_FFI_ERROR_NULL_POINTER;
163 }
164
165 if(flags != 0) {
166 return BOTAN_FFI_ERROR_BAD_FLAG;
167 }
168
169 if(wf < 4 || wf > 18) {
170 return BOTAN_FFI_ERROR_BAD_PARAMETER;
171 }
172
173 if(*out_len < 61) {
174 *out_len = 61;
175 return BOTAN_FFI_ERROR_INSUFFICIENT_BUFFER_SPACE;
176 }
177
178 Botan::RandomNumberGenerator& rng = safe_get(rng_obj);
179 const std::string bcrypt = Botan::generate_bcrypt(pass, rng, static_cast<uint16_t>(wf));
180 return write_str_output(out, out_len, bcrypt);
181 });
182#else
183 BOTAN_UNUSED(out, out_len, pass, rng_obj, wf, flags);
184 return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
185#endif
186}
BOTAN_UNUSED
#define BOTAN_UNUSED
Definition assert.h:118
Botan_FFI::safe_get
T & safe_get(botan_struct< T, M > *p)
Definition ffi_util.h:63
Botan::generate_bcrypt
std::string generate_bcrypt(std::string_view pass, RandomNumberGenerator &rng, uint16_t work_factor, char version)
Definition bcrypt.cpp:144

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
passthe password to check against
hashthe 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 188 of file ffi_kdf.cpp.

188 {
189#if defined(BOTAN_HAS_BCRYPT)
190 return ffi_guard_thunk(__func__, [=]() -> int {
191 return Botan::check_bcrypt(pass, hash) ? BOTAN_FFI_SUCCESS : BOTAN_FFI_INVALID_VERIFIER;
192 });
193#else
194 BOTAN_UNUSED(pass, hash);
195 return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
196#endif
197}
Botan::check_bcrypt
bool check_bcrypt(std::string_view pass, std::string_view hash)
Definition bcrypt.cpp:159

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 61 of file ffi_block.cpp.

61 {
62 return BOTAN_FFI_VISIT(bc, [](const auto& b) { return static_cast<int>(b.block_size()); });
63}
BOTAN_FFI_VISIT
#define BOTAN_FFI_VISIT(obj, lambda)
Definition ffi_util.h:124

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 43 of file ffi_block.cpp.

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

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 72 of file ffi_block.cpp.

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

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 39 of file ffi_block.cpp.

39 {
40 return BOTAN_FFI_CHECKED_DELETE(bc);
41}
BOTAN_FFI_CHECKED_DELETE
#define BOTAN_FFI_CHECKED_DELETE(o)
Definition ffi_util.h:143

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 65 of file ffi_block.cpp.

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

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
cipherthe object to read
out_minimum_keylengthif non-NULL, will be set to minimum keylength of cipher
out_maximum_keylengthif non-NULL, will be set to maximum keylength of cipher
out_keylength_moduloif non-NULL will be set to byte multiple of valid keys

Definition at line 87 of file ffi_block.cpp.

90 {
91 return BOTAN_FFI_VISIT(cipher, [=](const auto& bc) {
92 if(out_minimum_keylength)
93 *out_minimum_keylength = bc.minimum_keylength();
94 if(out_maximum_keylength)
95 *out_maximum_keylength = bc.maximum_keylength();
96 if(out_keylength_modulo)
97 *out_keylength_modulo = bc.key_spec().keylength_multiple();
98 });
99}

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.

18 {
19 return ffi_guard_thunk(__func__, [=]() -> int {
20 if(bc == nullptr || bc_name == nullptr || *bc_name == 0) {
21 return BOTAN_FFI_ERROR_NULL_POINTER;
22 }
23
24 *bc = nullptr;
25
26 auto cipher = Botan::BlockCipher::create(bc_name);
27 if(cipher == nullptr) {
28 return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
29 }
30
31 *bc = new botan_block_cipher_struct(std::move(cipher));
32 return BOTAN_FFI_SUCCESS;
33 });
34}
Botan::BlockCipher::create
static std::unique_ptr< BlockCipher > create(std::string_view algo_spec, std::string_view provider="")
Definition block_cipher.cpp:91

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

◆ 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
cipherthe object to read
nameoutput buffer
name_lenon input, the length of buffer, on success the number of bytes written

Definition at line 79 of file ffi_block.cpp.

79 {
80 if(name_len == nullptr) {
81 return BOTAN_FFI_ERROR_NULL_POINTER;
82 }
83
84 return BOTAN_FFI_VISIT(cipher, [=](const auto& bc) { return write_str_output(name, name_len, bc.name()); });
85}
name
std::string name
Definition commoncrypto_hash.cpp:24

References BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_VISIT, name, 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 50 of file ffi_block.cpp.

50 {
51 if(key == nullptr) {
52 return BOTAN_FFI_ERROR_NULL_POINTER;
53 }
54 return BOTAN_FFI_VISIT(bc, [=](auto& b) { b.set_key(key, len); });
55}

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

84 {
85 return BOTAN_FFI_VISIT(cipher, [](auto& c) { c.clear(); });
86}

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

80 {
81 return BOTAN_FFI_CHECKED_DELETE(cipher);
82}

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

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

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

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

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

110 {
111 return BOTAN_FFI_VISIT(cipher, [=](const auto& c) {
112 if(out_minimum_keylength)
113 *out_minimum_keylength = c.key_spec().minimum_keylength();
114 if(out_maximum_keylength)
115 *out_maximum_keylength = c.key_spec().maximum_keylength();
116 if(out_keylength_modulo)
117 *out_keylength_modulo = c.key_spec().keylength_multiple();
118 });
119}

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

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

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

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

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

63 {
64 return ffi_guard_thunk(__func__, [=]() -> int {
65 const bool encrypt_p = ((flags & BOTAN_CIPHER_INIT_FLAG_MASK_DIRECTION) == BOTAN_CIPHER_INIT_FLAG_ENCRYPT);
66 const Botan::Cipher_Dir dir = encrypt_p ? Botan::Cipher_Dir::Encryption : Botan::Cipher_Dir::Decryption;
67
68 std::unique_ptr<Botan::Cipher_Mode> mode(Botan::Cipher_Mode::create(cipher_name, dir));
69 if(!mode) {
70 return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
71 }
72
73 const size_t update_size = ffi_choose_update_size(*mode);
74
75 *cipher = new botan_cipher_struct(std::move(mode), update_size);
76 return BOTAN_FFI_SUCCESS;
77 });
78}
Botan::Cipher_Mode::create
static std::unique_ptr< Cipher_Mode > create(std::string_view algo, Cipher_Dir direction, std::string_view provider="")
Definition cipher_mode.cpp:51
BOTAN_CIPHER_INIT_FLAG_ENCRYPT
#define BOTAN_CIPHER_INIT_FLAG_ENCRYPT
Definition ffi.h:527
BOTAN_CIPHER_INIT_FLAG_MASK_DIRECTION
#define BOTAN_CIPHER_INIT_FLAG_MASK_DIRECTION
Definition ffi.h:526
Botan::PKCS11::flags
Flags flags(Flag flags)
Definition p11.h:836

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

◆ 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 245 of file ffi_cipher.cpp.

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

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

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

References BOTAN_FFI_VISIT, name, 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 92 of file ffi_cipher.cpp.

92 {
93 if(out_len == nullptr) {
94 return BOTAN_FFI_ERROR_NULL_POINTER;
95 }
96
97 return BOTAN_FFI_VISIT(cipher, [=](const auto& c) { *out_len = c.output_length(in_len); });
98}

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

100 {
101 return BOTAN_FFI_VISIT(cipher, [=](const auto& c) {
102 *out_minimum_keylength = c.key_spec().minimum_keylength();
103 *out_maximum_keylength = c.key_spec().maximum_keylength();
104 });
105}

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

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

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

88 {
89 return BOTAN_FFI_VISIT(cipher, [](auto& c) { c.reset(); });
90}

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

215 {
216 return BOTAN_FFI_VISIT(cipher, [=](auto& c) {
217 if(Botan::AEAD_Mode* aead = dynamic_cast<Botan::AEAD_Mode*>(&c)) {
218 aead->set_associated_data(ad, ad_len);
219 return BOTAN_FFI_SUCCESS;
220 }
221 return BOTAN_FFI_ERROR_BAD_PARAMETER;
222 });
223}
Botan::AEAD_Mode
Definition aead.h:24

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

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

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

125 {
126 return ffi_guard_thunk(__func__, [=]() -> int {
127 Botan::Cipher_Mode& cipher = safe_get(cipher_obj);
128 cipher.start(nonce, nonce_len);
129 return BOTAN_FFI_SUCCESS;
130 });
131}
Botan::Cipher_Mode
Definition cipher_mode.h:37
Botan::Cipher_Mode::start
void start(std::span< const uint8_t > nonce)
Definition cipher_mode.h:89

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 some data

Definition at line 133 of file ffi_cipher.cpp.

140 {
141 return ffi_guard_thunk(__func__, [=]() -> int {
142 size_t input_size = orig_input_size;
143 size_t output_size = orig_output_size;
144 const uint8_t* input = input_ptr;
145 uint8_t* output = output_ptr;
146
147 using namespace Botan;
148 Cipher_Mode& cipher = safe_get(cipher_obj);
149 secure_vector<uint8_t>& mbuf = cipher_obj->buf();
150
151 const bool final_input = (flags & BOTAN_CIPHER_UPDATE_FLAG_FINAL);
152
153 if(final_input) {
154 mbuf.assign(input, input + input_size);
155 *input_consumed = input_size;
156 *output_written = 0;
157
158 try {
159 cipher.finish(mbuf);
160 } catch(Invalid_Authentication_Tag&) {
161 return BOTAN_FFI_ERROR_BAD_MAC;
162 }
163
164 *output_written = mbuf.size();
165
166 if(mbuf.size() <= output_size) {
167 copy_mem(output, mbuf.data(), mbuf.size());
168 mbuf.clear();
169 return BOTAN_FFI_SUCCESS;
170 }
171
172 return -1;
173 }
174
175 if(input_size == 0) {
176 // Currently must take entire buffer in this case
177 *output_written = mbuf.size();
178 if(output_size >= mbuf.size()) {
179 copy_mem(output, mbuf.data(), mbuf.size());
180 mbuf.clear();
181 return BOTAN_FFI_SUCCESS;
182 }
183
184 return -1;
185 }
186
187 const size_t ud = cipher_obj->update_size();
188
189 mbuf.resize(ud);
190 size_t taken = 0, written = 0;
191
192 while(input_size >= ud && output_size >= ud) {
193 copy_mem(mbuf.data(), input, ud);
194 const size_t bytes_produced = cipher.process(mbuf);
195
196 input_size -= ud;
197 input += ud;
198 taken += ud;
199
200 if(bytes_produced > 0) {
201 copy_mem(output, mbuf.data(), bytes_produced);
202 output_size -= bytes_produced;
203 output += bytes_produced;
204 written += bytes_produced;
205 }
206 }
207
208 *output_written = written;
209 *input_consumed = taken;
210
211 return BOTAN_FFI_SUCCESS;
212 });
213}
Botan::Cipher_Mode::finish
void finish(secure_vector< uint8_t > &final_block, size_t offset=0)
Definition cipher_mode.h:146
Botan::Cipher_Mode::process
size_t process(std::span< uint8_t > msg)
Definition cipher_mode.h:123
Botan::Invalid_Authentication_Tag
Definition exceptn.h:273
BOTAN_CIPHER_UPDATE_FLAG_FINAL
#define BOTAN_CIPHER_UPDATE_FLAG_FINAL
Definition ffi.h:621
Botan::secure_vector
std::vector< T, secure_allocator< T > > secure_vector
Definition secmem.h:61
Botan::copy_mem
constexpr void copy_mem(T *out, const T *in, size_t n)
Definition mem_ops.h:146

References BOTAN_CIPHER_UPDATE_FLAG_FINAL, BOTAN_FFI_ERROR_BAD_MAC, BOTAN_FFI_SUCCESS, Botan_FFI::ffi_guard_thunk(), Botan::Cipher_Mode::finish(), Botan::Cipher_Mode::process(), 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 225 of file ffi_cipher.cpp.

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

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

298 {
299 auto same = Botan::CT::is_equal(x, y, len);
300 // Return 0 if same or -1 otherwise
301 return static_cast<int>(same.select(1, 0)) - 1;
302}
Botan::CT::is_equal
constexpr CT::Mask< T > is_equal(const T x[], const T y[], size_t len)
Definition ct_utils.h:345

References Botan::CT::is_equal().

Referenced by botan_same_mem().

◆ 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 146 of file ffi.cpp.

146 {
147 switch(err) {
148 case BOTAN_FFI_SUCCESS:
149 return "OK";
150
151 case BOTAN_FFI_INVALID_VERIFIER:
152 return "Invalid verifier";
153
154 case BOTAN_FFI_ERROR_INVALID_INPUT:
155 return "Invalid input";
156
157 case BOTAN_FFI_ERROR_BAD_MAC:
158 return "Invalid authentication code";
159
160 case BOTAN_FFI_ERROR_INSUFFICIENT_BUFFER_SPACE:
161 return "Insufficient buffer space";
162
163 case BOTAN_FFI_ERROR_STRING_CONVERSION_ERROR:
164 return "String conversion error";
165
166 case BOTAN_FFI_ERROR_EXCEPTION_THROWN:
167 return "Exception thrown";
168
169 case BOTAN_FFI_ERROR_OUT_OF_MEMORY:
170 return "Out of memory";
171
172 case BOTAN_FFI_ERROR_SYSTEM_ERROR:
173 return "Error while calling system API";
174
175 case BOTAN_FFI_ERROR_INTERNAL_ERROR:
176 return "Internal error";
177
178 case BOTAN_FFI_ERROR_BAD_FLAG:
179 return "Bad flag";
180
181 case BOTAN_FFI_ERROR_NULL_POINTER:
182 return "Null pointer argument";
183
184 case BOTAN_FFI_ERROR_BAD_PARAMETER:
185 return "Bad parameter";
186
187 case BOTAN_FFI_ERROR_KEY_NOT_SET:
188 return "Key not set on object";
189
190 case BOTAN_FFI_ERROR_INVALID_KEY_LENGTH:
191 return "Invalid key length";
192
193 case BOTAN_FFI_ERROR_INVALID_OBJECT_STATE:
194 return "Invalid object state";
195
196 case BOTAN_FFI_ERROR_NOT_IMPLEMENTED:
197 return "Not implemented";
198
199 case BOTAN_FFI_ERROR_INVALID_OBJECT:
200 return "Invalid object handle";
201
202 case BOTAN_FFI_ERROR_TLS_ERROR:
203 return "TLS error";
204
205 case BOTAN_FFI_ERROR_HTTP_ERROR:
206 return "HTTP error";
207
208 case BOTAN_FFI_ERROR_UNKNOWN_ERROR:
209 return "Unknown error";
210
211 default:
212 return "Unknown error";
213 }
214}

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_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_ERROR_OUT_OF_MEMORY, 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 142 of file ffi.cpp.

142 {
143 return g_last_exception_what.c_str();
144}
Botan_FFI::g_last_exception_what
thread_local std::string g_last_exception_what
Definition ffi.cpp:22

References Botan_FFI::g_last_exception_what.

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

219 {
220 return BOTAN_HAS_FFI;
221}
BOTAN_HAS_FFI
#define BOTAN_HAS_FFI
Definition build.h:220

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.

223 {
224 // This is the API introduced in 3.4
225 if(api_version == 20240408) {
226 return BOTAN_FFI_SUCCESS;
227 }
228
229 // This is the API introduced in 3.2
230 if(api_version == 20231009) {
231 return BOTAN_FFI_SUCCESS;
232 }
233
234 // This is the API introduced in 3.1
235 if(api_version == 20230711) {
236 return BOTAN_FFI_SUCCESS;
237 }
238
239 // This is the API introduced in 3.0
240 if(api_version == 20230403) {
241 return BOTAN_FFI_SUCCESS;
242 }
243
244 // This is the API introduced in 2.18
245 if(api_version == 20210220) {
246 return BOTAN_FFI_SUCCESS;
247 }
248
249 // This is the API introduced in 2.13
250 if(api_version == 20191214) {
251 return BOTAN_FFI_SUCCESS;
252 }
253
254 // This is the API introduced in 2.8
255 if(api_version == 20180713) {
256 return BOTAN_FFI_SUCCESS;
257 }
258
259 // This is the API introduced in 2.3
260 if(api_version == 20170815) {
261 return BOTAN_FFI_SUCCESS;
262 }
263
264 // This is the API introduced in 2.1
265 if(api_version == 20170327) {
266 return BOTAN_FFI_SUCCESS;
267 }
268
269 // This is the API introduced in 2.0
270 if(api_version == 20150515) {
271 return BOTAN_FFI_SUCCESS;
272 }
273
274 // Something else:
275 return -1;
276}

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.

78 {
79#if defined(BOTAN_HAS_FPE_FE1)
80 return ffi_guard_thunk(__func__, [=]() {
81 Botan::BigInt r = safe_get(fpe).decrypt(safe_get(x), tweak, tweak_len);
82 safe_get(x) = r;
83 return BOTAN_FFI_SUCCESS;
84 });
85
86#else
87 BOTAN_UNUSED(fpe, x, tweak, tweak_len);
88 return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
89#endif
90}

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.

56 {
57#if defined(BOTAN_HAS_FPE_FE1)
58 return BOTAN_FFI_CHECKED_DELETE(fpe);
59#else
60 BOTAN_UNUSED(fpe);
61 return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
62#endif
63}

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.

65 {
66#if defined(BOTAN_HAS_FPE_FE1)
67 return ffi_guard_thunk(__func__, [=]() {
68 Botan::BigInt r = safe_get(fpe).encrypt(safe_get(x), tweak, tweak_len);
69 safe_get(x) = r;
70 return BOTAN_FFI_SUCCESS;
71 });
72#else
73 BOTAN_UNUSED(fpe, x, tweak, tweak_len);
74 return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
75#endif
76}

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 27 of file ffi_fpe.cpp.

28 {
29#if defined(BOTAN_HAS_FPE_FE1)
30 return ffi_guard_thunk(__func__, [=]() {
31 if(fpe == nullptr || key == nullptr) {
32 return BOTAN_FFI_ERROR_NULL_POINTER;
33 }
34
35 *fpe = nullptr;
36
37 if(flags != 0 && flags != BOTAN_FPE_FLAG_FE1_COMPAT_MODE) {
38 return BOTAN_FFI_ERROR_BAD_FLAG;
39 }
40
41 const bool compat_mode = (flags & BOTAN_FPE_FLAG_FE1_COMPAT_MODE);
42
43 std::unique_ptr<Botan::FPE_FE1> fpe_obj(new Botan::FPE_FE1(safe_get(n), rounds, compat_mode));
44
45 fpe_obj->set_key(key, key_len);
46
47 *fpe = new botan_fpe_struct(std::move(fpe_obj));
48 return BOTAN_FFI_SUCCESS;
49 });
50#else
51 BOTAN_UNUSED(fpe, n, key, key_len, rounds, flags);
52 return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
53#endif
54}
Botan::FPE_FE1
Definition fpe_fe1.h:24
BOTAN_FPE_FLAG_FE1_COMPAT_MODE
#define BOTAN_FPE_FLAG_FE1_COMPAT_MODE
Definition ffi.h:1998

References BOTAN_FFI_ERROR_BAD_FLAG, BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_SUCCESS, BOTAN_FPE_FLAG_FE1_COMPAT_MODE, BOTAN_UNUSED, Botan_FFI::ffi_guard_thunk(), 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
hashhash object
block_sizeoutput 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.

48 {
49 if(out == nullptr) {
50 return BOTAN_FFI_ERROR_NULL_POINTER;
51 }
52 return BOTAN_FFI_VISIT(hash, [=](const auto& h) { *out = h.hash_block_size(); });
53}

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
hashhash object
Returns
0 on success, a negative value on failure

Definition at line 55 of file ffi_hash.cpp.

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

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
destdestination hash object
sourcesource hash object
Returns
0 on success, a negative value on failure

Definition at line 78 of file ffi_hash.cpp.

78 {
79 return BOTAN_FFI_VISIT(source, [=](const auto& src) { *dest = new botan_hash_struct(src.copy_state()); });
80}

References BOTAN_FFI_VISIT.

◆ botan_hash_destroy()

int botan_hash_destroy ( botan_hash_t hash)

Frees all resources of the hash object

Parameters
hashhash object
Returns
0 if success, error if invalid object handle

Definition at line 37 of file ffi_hash.cpp.

37 {
38 return BOTAN_FFI_CHECKED_DELETE(hash);
39}

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
hashhash object
outoutput buffer
Returns
0 on success, a negative value on failure

Definition at line 71 of file ffi_hash.cpp.

71 {
72 if(out == nullptr) {
73 return BOTAN_FFI_ERROR_NULL_POINTER;
74 }
75 return BOTAN_FFI_VISIT(hash, [=](auto& h) { h.final(out); });
76}

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
hashhash object
hash_namename of the hash function, e.g., "SHA-384"
flagsshould 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.

18 {
19 return ffi_guard_thunk(__func__, [=]() -> int {
20 if(hash == nullptr || hash_name == nullptr || *hash_name == 0) {
21 return BOTAN_FFI_ERROR_NULL_POINTER;
22 }
23 if(flags != 0) {
24 return BOTAN_FFI_ERROR_BAD_FLAG;
25 }
26
27 auto h = Botan::HashFunction::create(hash_name);
28 if(h == nullptr) {
29 return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
30 }
31
32 *hash = new botan_hash_struct(std::move(h));
33 return BOTAN_FFI_SUCCESS;
34 });
35}
Botan::HashFunction::create
static std::unique_ptr< HashFunction > create(std::string_view algo_spec, std::string_view provider="")
Definition hash.cpp:107

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

◆ 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
hashthe object to read
nameoutput buffer
name_lenon input, the length of buffer, on success the number of bytes written

Definition at line 82 of file ffi_hash.cpp.

82 {
83 if(name_len == nullptr) {
84 return BOTAN_FFI_ERROR_NULL_POINTER;
85 }
86
87 return BOTAN_FFI_VISIT(hash, [=](const auto& h) { return write_str_output(name, name_len, h.name()); });
88}

References BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_VISIT, name, 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
hashhash object
output_lengthoutput 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.

41 {
42 if(out == nullptr) {
43 return BOTAN_FFI_ERROR_NULL_POINTER;
44 }
45 return BOTAN_FFI_VISIT(hash, [=](const auto& h) { *out = h.output_length(); });
46}

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
hashhash object
ininput buffer
in_lennumber 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.

59 {
60 if(len == 0) {
61 return 0;
62 }
63
64 if(buf == nullptr) {
65 return BOTAN_FFI_ERROR_NULL_POINTER;
66 }
67
68 return BOTAN_FFI_VISIT(hash, [=](auto& h) { h.update(buf, len); });
69}

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_stra string of hex chars (whitespace is ignored)
in_lenthe length of hex_str
outthe output buffer should be at least strlen(hex_str)/2 bytes
out_lenthe 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 321 of file ffi.cpp.

321 {
322 return ffi_guard_thunk(__func__, [=]() -> int {
323 const std::vector<uint8_t> bin = Botan::hex_decode(hex_str, in_len);
324 return Botan_FFI::write_vec_output(out, out_len, bin);
325 });
326}
Botan_FFI::write_vec_output
int write_vec_output(uint8_t out[], size_t *out_len, const std::vector< uint8_t, Alloc > &buf)
Definition ffi_util.h:201
Botan::hex_decode
size_t hex_decode(uint8_t output[], const char input[], size_t input_length, size_t &input_consumed, bool ignore_ws)
Definition hex.cpp:81

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
xis some binary data
lenlength of x in bytes
outan array of at least x*2 bytes
flagsflags out be upper or lower case?
Returns
0 on success, a negative value on failure

Definition at line 313 of file ffi.cpp.

313 {
314 return ffi_guard_thunk(__func__, [=]() -> int {
315 const bool uppercase = (flags & BOTAN_FFI_HEX_LOWER_CASE) == 0;
316 Botan::hex_encode(out, in, len, uppercase);
317 return BOTAN_FFI_SUCCESS;
318 });
319}
BOTAN_FFI_HEX_LOWER_CASE
#define BOTAN_FFI_HEX_LOWER_CASE
Definition ffi.h:225
Botan::hex_encode
void hex_encode(char output[], const uint8_t input[], size_t input_length, bool uppercase)
Definition hex.cpp:33

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 68 of file ffi_hotp.cpp.

69 {
70#if defined(BOTAN_HAS_HOTP)
71 return BOTAN_FFI_VISIT(hotp, [=](auto& h) {
72 auto resp = h.verify_hotp(hotp_code, hotp_counter, resync_range);
73
74 if(next_hotp_counter)
75 *next_hotp_counter = resp.second;
76
77 return (resp.first == true) ? BOTAN_FFI_SUCCESS : BOTAN_FFI_INVALID_VERIFIER;
78 });
79
80#else
81 BOTAN_UNUSED(hotp, next_hotp_counter, hotp_code, hotp_counter, resync_range);
82 return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
83#endif
84}

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 45 of file ffi_hotp.cpp.

45 {
46#if defined(BOTAN_HAS_HOTP)
47 return BOTAN_FFI_CHECKED_DELETE(hotp);
48#else
49 BOTAN_UNUSED(hotp);
50 return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
51#endif
52}

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 54 of file ffi_hotp.cpp.

54 {
55#if defined(BOTAN_HAS_HOTP)
56 if(hotp == nullptr || hotp_code == nullptr) {
57 return BOTAN_FFI_ERROR_NULL_POINTER;
58 }
59
60 return BOTAN_FFI_VISIT(hotp, [=](auto& h) { *hotp_code = h.generate_hotp(hotp_counter); });
61
62#else
63 BOTAN_UNUSED(hotp, hotp_code, hotp_counter);
64 return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
65#endif
66}

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 25 of file ffi_hotp.cpp.

25 {
26 if(hotp == nullptr || key == nullptr || hash_algo == nullptr) {
27 return BOTAN_FFI_ERROR_NULL_POINTER;
28 }
29
30 *hotp = nullptr;
31
32#if defined(BOTAN_HAS_HOTP)
33 return ffi_guard_thunk(__func__, [=]() -> int {
34 auto otp = std::make_unique<Botan::HOTP>(key, key_len, hash_algo, digits);
35 *hotp = new botan_hotp_struct(std::move(otp));
36
37 return BOTAN_FFI_SUCCESS;
38 });
39#else
40 BOTAN_UNUSED(hotp, key, key_len, hash_algo, digits);
41 return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
42#endif
43}

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

◆ 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_algoKDF algorithm, e.g., "SP800-56C"
outbuffer holding the derived key, must be of length out_len
out_lenthe desired output length in bytes
secretthe secret input
secret_lensize of secret in bytes
salta diversifier
salt_lensize of salt in bytes
labelpurpose for the derived keying material
label_lensize of label in bytes
Returns
0 on success, a negative value on failure

Definition at line 130 of file ffi_kdf.cpp.

138 {
139 return ffi_guard_thunk(__func__, [=]() -> int {
140 auto kdf = Botan::KDF::create_or_throw(kdf_algo);
141 kdf->kdf(out, out_len, secret, secret_len, salt, salt_len, label, label_len);
142 return BOTAN_FFI_SUCCESS;
143 });
144}
Botan::KDF::create_or_throw
static std::unique_ptr< KDF > create_or_throw(std::string_view algo_spec, std::string_view provider="")
Definition kdf.cpp:193

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 97 of file ffi_keywrap.cpp.

102 {
103 std::string cipher_name = "AES-" + std::to_string(8 * kek_len);
104
105 return botan_nist_kw_dec(cipher_name.c_str(), 0, wrapped_key, wrapped_key_len, kek, kek_len, key, key_len);
106}
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 ffi_keywrap.cpp:53

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 86 of file ffi_keywrap.cpp.

91 {
92 std::string cipher_name = "AES-" + std::to_string(8 * kek_len);
93
94 return botan_nist_kw_enc(cipher_name.c_str(), 0, key, key_len, kek, kek_len, wrapped_key, wrapped_key_len);
95}
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 ffi_keywrap.cpp:21

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
macmac object
Returns
0 on success, a negative value on failure

Definition at line 51 of file ffi_mac.cpp.

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

References BOTAN_FFI_VISIT.

◆ botan_mac_destroy()

int botan_mac_destroy ( botan_mac_t mac)

Frees all resources of the MAC object

Parameters
macmac object
Returns
0 if success, error if invalid object handle

Definition at line 35 of file ffi_mac.cpp.

35 {
36 return BOTAN_FFI_CHECKED_DELETE(mac);
37}

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
macmac object
outoutput buffer
Returns
0 on success, a negative value on failure

Definition at line 59 of file ffi_mac.cpp.

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

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
macthe object to read
out_minimum_keylengthif non-NULL, will be set to minimum keylength of MAC
out_maximum_keylengthif non-NULL, will be set to maximum keylength of MAC
out_keylength_moduloif non-NULL will be set to byte multiple of valid keys

Definition at line 67 of file ffi_mac.cpp.

70 {
71 return BOTAN_FFI_VISIT(mac, [=](auto& m) {
72 if(out_minimum_keylength)
73 *out_minimum_keylength = m.minimum_keylength();
74 if(out_maximum_keylength)
75 *out_maximum_keylength = m.maximum_keylength();
76 if(out_keylength_modulo)
77 *out_keylength_modulo = m.key_spec().keylength_multiple();
78 });
79}

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
macmac object
mac_namename of the hash function, e.g., "HMAC(SHA-384)"
flagsshould 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.

18 {
19 return ffi_guard_thunk(__func__, [=]() -> int {
20 if(!mac || !mac_name || flags != 0) {
21 return BOTAN_FFI_ERROR_NULL_POINTER;
22 }
23
24 std::unique_ptr<Botan::MessageAuthenticationCode> m = Botan::MessageAuthenticationCode::create(mac_name);
25
26 if(m == nullptr) {
27 return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
28 }
29
30 *mac = new botan_mac_struct(std::move(m));
31 return BOTAN_FFI_SUCCESS;
32 });
33}
Botan::MessageAuthenticationCode::create
static std::unique_ptr< MessageAuthenticationCode > create(std::string_view algo_spec, std::string_view provider="")
Definition mac.cpp:51

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

◆ botan_mac_name()

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

Get the name of this MAC

Parameters
macthe object to read
nameoutput buffer
name_lenon input, the length of buffer, on success the number of bytes written

Definition at line 63 of file ffi_mac.cpp.

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

References BOTAN_FFI_VISIT, name, 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
macmac object
output_lengthoutput buffer to hold the MAC output length
Returns
0 on success, a negative value on failure

Definition at line 47 of file ffi_mac.cpp.

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

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
macmac object
keybuffer holding the key
key_lensize of the key buffer in bytes
Returns
0 on success, a negative value on failure

Definition at line 39 of file ffi_mac.cpp.

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

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
macmac object
noncebuffer holding the key
nonce_lensize of the key buffer in bytes
Returns
0 on success, a negative value on failure

Definition at line 43 of file ffi_mac.cpp.

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

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
macmac object
bufinput buffer
lennumber of bytes to read from the input buffer
Returns
0 on success, a negative value on failure

Definition at line 55 of file ffi_mac.cpp.

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

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 1047 of file ffi_pkey_algs.cpp.

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

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 1059 of file ffi_pkey_algs.cpp.

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

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

116 {
117 return BOTAN_FFI_VISIT(result, [=](auto& res) {
118 if(result == x)
119 res += safe_get(y);
120 else
121 res = safe_get(x) + safe_get(y);
122 });
123}

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

134 {
135 return BOTAN_FFI_VISIT(result, [=](auto& res) {
136 if(result == x)
137 res += static_cast<Botan::word>(y);
138 else
139 res = safe_get(x) + static_cast<Botan::word>(y);
140 });
141}

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

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

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

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

References BOTAN_FFI_VISIT.

◆ botan_mp_cmp()

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

Definition at line 185 of file ffi_mp.cpp.

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

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

112 {
113 return BOTAN_FFI_CHECKED_DELETE(mp);
114}

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

161 {
162 return BOTAN_FFI_VISIT(quotient, [=](auto& q) {
163 Botan::BigInt r;
164 Botan::vartime_divide(safe_get(x), safe_get(y), q, r);
165 safe_get(remainder) = r;
166 });
167}
Botan::vartime_divide
void vartime_divide(const BigInt &x, const BigInt &y_arg, BigInt &q_out, BigInt &r_out)
Definition divide.cpp:155

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

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

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

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

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

79 {
80 return BOTAN_FFI_VISIT(mp, [=](auto& bn) { bn.binary_decode(bin, bin_len); });
81}

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

227 {
228 return BOTAN_FFI_VISIT(out, [=](auto& o) { o = Botan::gcd(safe_get(x), safe_get(y)); });
229}
Botan::gcd
BigInt gcd(const BigInt &a, const BigInt &b)
Definition numthry.cpp:193

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

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

References BOTAN_FFI_VISIT.

◆ botan_mp_init()

int botan_mp_init ( botan_mp_t * mp)

Initialize an MPI

Definition at line 21 of file ffi_mp.cpp.

21 {
22 return ffi_guard_thunk(__func__, [=]() -> int {
23 if(mp_out == nullptr) {
24 return BOTAN_FFI_ERROR_NULL_POINTER;
25 }
26
27 auto mp = std::make_unique<Botan::BigInt>();
28 *mp_out = new botan_mp_struct(std::move(mp));
29 return BOTAN_FFI_SUCCESS;
30 });
31}

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

◆ botan_mp_is_even()

int botan_mp_is_even ( botan_mp_t mp)

Definition at line 181 of file ffi_mp.cpp.

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

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

67 {
68 return BOTAN_FFI_VISIT(mp, [](const auto& bn) { return bn.is_negative() ? 1 : 0; });
69}

References BOTAN_FFI_VISIT.

◆ botan_mp_is_odd()

int botan_mp_is_odd ( botan_mp_t mp)

Definition at line 177 of file ffi_mp.cpp.

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

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

71 {
72 return BOTAN_FFI_VISIT(mp, [](const auto& bn) { return bn.is_positive() ? 1 : 0; });
73}

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

231 {
232 return BOTAN_FFI_VISIT(mp, [=](const auto& n) { return (Botan::is_prime(n, safe_get(rng), test_prob)) ? 1 : 0; });
233}
Botan::is_prime
bool is_prime(const BigInt &n, RandomNumberGenerator &rng, size_t prob, bool is_random)
Definition numthry.cpp:357

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

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

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

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

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

207 {
208 return BOTAN_FFI_VISIT(out, [=](auto& o) { o = Botan::inverse_mod(safe_get(in), safe_get(modulus)); });
209}
Botan::inverse_mod
BigInt inverse_mod(const BigInt &n, const BigInt &mod)
Definition mod_inv.cpp:178

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

◆ 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 211 of file ffi_mp.cpp.

211 {
212 return BOTAN_FFI_VISIT(out, [=](auto& o) {
213 Botan::Modular_Reducer reducer(safe_get(modulus));
214 o = reducer.multiply(safe_get(x), safe_get(y));
215 });
216}
Botan::Modular_Reducer
Definition reducer.h:18

References BOTAN_FFI_VISIT, Botan::Modular_Reducer::multiply(), 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 152 of file ffi_mp.cpp.

152 {
153 return BOTAN_FFI_VISIT(result, [=](auto& res) {
154 if(result == x)
155 res *= safe_get(y);
156 else
157 res = safe_get(x) * safe_get(y);
158 });
159}

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

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

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

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

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

194 {
195 return BOTAN_FFI_VISIT(
196 out, [=](auto& o) { o = Botan::power_mod(safe_get(base), safe_get(exponent), safe_get(modulus)); });
197}
Botan::power_mod
BigInt power_mod(const BigInt &base, const BigInt &exp, const BigInt &mod)
Definition numthry.cpp:286

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

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

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

222 {
223 return BOTAN_FFI_VISIT(
224 rng, [=](auto& r) { safe_get(rand_out) = Botan::BigInt::random_integer(r, safe_get(lower), safe_get(upper)); });
225}
Botan::BigInt::random_integer
static BigInt random_integer(RandomNumberGenerator &rng, const BigInt &min, const BigInt &max)
Definition big_rand.cpp:43

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

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

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

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

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

37 {
38 return BOTAN_FFI_VISIT(mp, [=](auto& bn) { bn = Botan::BigInt::from_s32(initial_value); });
39}
Botan::BigInt::from_s32
static BigInt from_s32(int32_t n)
Definition bigint.cpp:49

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

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

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

45 {
46 return BOTAN_FFI_VISIT(mp, [=](auto& bn) {
47 Botan::BigInt::Base base;
48 if(radix == 10)
49 base = Botan::BigInt::Decimal;
50 else if(radix == 16)
51 base = Botan::BigInt::Hexadecimal;
52 else
53 return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
54
55 const uint8_t* bytes = Botan::cast_char_ptr_to_uint8(str);
56 const size_t len = strlen(str);
57
58 bn = Botan::BigInt(bytes, len, base);
59 return BOTAN_FFI_SUCCESS;
60 });
61}
Botan::cast_char_ptr_to_uint8
const uint8_t * cast_char_ptr_to_uint8(const char *s)
Definition mem_ops.h:275

References BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_SUCCESS, BOTAN_FFI_VISIT, Botan::cast_char_ptr_to_uint8(), Botan::BigInt::Decimal, and Botan::BigInt::Hexadecimal.

◆ 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 41 of file ffi_mp.cpp.

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

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

125 {
126 return BOTAN_FFI_VISIT(result, [=](auto& res) {
127 if(result == x)
128 res -= safe_get(y);
129 else
130 res = safe_get(x) - safe_get(y);
131 });
132}

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

143 {
144 return BOTAN_FFI_VISIT(result, [=](auto& res) {
145 if(result == x)
146 res -= static_cast<Botan::word>(y);
147 else
148 res = safe_get(x) - static_cast<Botan::word>(y);
149 });
150}

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

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

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

101 {
102 return BOTAN_FFI_VISIT(mp, [=](const auto& bn) { bn.binary_encode(vec); });
103}

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 botan_mp_num_bytes(mp)*2 + 1 bytes

Definition at line 83 of file ffi_mp.cpp.

83 {
84 return BOTAN_FFI_VISIT(mp, [=](const auto& bn) {
85 const std::string hex = bn.to_hex_string();
86 std::memcpy(out, hex.c_str(), 1 + hex.size());
87 });
88}

References BOTAN_FFI_VISIT.

◆ botan_mp_to_str()

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

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

Definition at line 90 of file ffi_mp.cpp.

90 {
91 return BOTAN_FFI_VISIT(mp, [=](const auto& bn) -> int {
92 if(digit_base == 0 || digit_base == 10)
93 return write_str_output(out, out_len, bn.to_dec_string());
94 else if(digit_base == 16)
95 return write_str_output(out, out_len, bn.to_hex_string());
96 else
97 return BOTAN_FFI_ERROR_BAD_PARAMETER;
98 });
99}

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

105 {
106 if(val == nullptr) {
107 return BOTAN_FFI_ERROR_NULL_POINTER;
108 }
109 return BOTAN_FFI_VISIT(mp, [=](const auto& bn) { *val = bn.to_u32bit(); });
110}

References BOTAN_FFI_ERROR_NULL_POINTER, and BOTAN_FFI_VISIT.

◆ 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 53 of file ffi_keywrap.cpp.

60 {
61#if defined(BOTAN_HAS_NIST_KEYWRAP)
62 return ffi_guard_thunk(__func__, [=]() -> int {
63 if(padded != 0 && padded != 1) {
64 return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
65 }
66
67 auto bc = Botan::BlockCipher::create_or_throw(cipher_algo);
68 bc->set_key(kek, kek_len);
69
70 Botan::secure_vector<uint8_t> output;
71
72 if(padded == 0) {
73 output = Botan::nist_key_unwrap(wrapped_key, wrapped_key_len, *bc);
74 } else {
75 output = Botan::nist_key_unwrap_padded(wrapped_key, wrapped_key_len, *bc);
76 }
77
78 return write_vec_output(key, key_len, output);
79 });
80#else
81 BOTAN_UNUSED(cipher_algo, padded, key, key_len, kek, kek_len, wrapped_key, wrapped_key_len);
82 return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
83#endif
84}
Botan::BlockCipher::create_or_throw
static std::unique_ptr< BlockCipher > create_or_throw(std::string_view algo_spec, std::string_view provider="")
Definition block_cipher.cpp:266
Botan::nist_key_unwrap_padded
secure_vector< uint8_t > nist_key_unwrap_padded(const uint8_t input[], size_t input_len, const BlockCipher &bc)
Definition nist_keywrap.cpp:169
Botan::nist_key_unwrap
secure_vector< uint8_t > nist_key_unwrap(const uint8_t input[], size_t input_len, const BlockCipher &bc)
Definition nist_keywrap.cpp:116

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 21 of file ffi_keywrap.cpp.

28 {
29#if defined(BOTAN_HAS_NIST_KEYWRAP)
30 return ffi_guard_thunk(__func__, [=]() -> int {
31 if(padded != 0 && padded != 1) {
32 return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
33 }
34 auto bc = Botan::BlockCipher::create_or_throw(cipher_algo);
35 bc->set_key(kek, kek_len);
36
37 std::vector<uint8_t> output;
38
39 if(padded == 0) {
40 output = Botan::nist_key_wrap(key, key_len, *bc);
41 } else {
42 output = Botan::nist_key_wrap_padded(key, key_len, *bc);
43 }
44
45 return write_vec_output(wrapped_key, wrapped_key_len, output);
46 });
47#else
48 BOTAN_UNUSED(cipher_algo, padded, key, key_len, kek, kek_len, wrapped_key, wrapped_key_len);
49 return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
50#endif
51}
Botan::nist_key_wrap
std::vector< uint8_t > nist_key_wrap(const uint8_t input[], size_t input_len, const BlockCipher &bc)
Definition nist_keywrap.cpp:90
Botan::nist_key_wrap_padded
std::vector< uint8_t > nist_key_wrap_padded(const uint8_t input[], size_t input_len, const BlockCipher &bc)
Definition nist_keywrap.cpp:148

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

28 {
29 return botan_pwdhash(algo, iterations, 0, 0, out, out_len, pass, 0, salt, salt_len);
30}
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 *password, size_t password_len, const uint8_t salt[], size_t salt_len)
Definition ffi_kdf.cpp:53

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_algoPBKDF algorithm, e.g., "PBKDF2(SHA-256)"
outbuffer to store the derived key, must be of out_len bytes
out_lenthe desired length of the key to produce
passphrasethe password to derive the key from
salta randomly chosen salt
salt_lenlength of salt in bytes
milliseconds_to_runif iterations is zero, then instead the PBKDF is run until milliseconds_to_run milliseconds has passed
out_iterations_usedset 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.

39 {
40 return botan_pwdhash_timed(algo,
41 static_cast<uint32_t>(ms_to_run),
42 iterations_used,
43 nullptr,
44 nullptr,
45 out,
46 out_len,
47 password,
48 0,
49 salt,
50 salt_len);
51}
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 *password, size_t password_len, const uint8_t salt[], size_t salt_len)
Definition ffi_kdf.cpp:86

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 103 of file ffi_pk_op.cpp.

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

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 71 of file ffi_pk_op.cpp.

74 {
75 if(op == nullptr) {
76 return BOTAN_FFI_ERROR_NULL_POINTER;
77 }
78
79 if(flags != 0) {
80 return BOTAN_FFI_ERROR_BAD_FLAG;
81 }
82
83 return ffi_guard_thunk(__func__, [=]() -> int {
84 *op = nullptr;
85
86 auto pk = std::make_unique<Botan::PK_Decryptor_EME>(safe_get(key_obj), Botan::system_rng(), padding);
87 *op = new botan_pk_op_decrypt_struct(std::move(pk));
88 return BOTAN_FFI_SUCCESS;
89 });
90}
Botan::system_rng
RandomNumberGenerator & system_rng()
Definition system_rng.cpp:368

References BOTAN_FFI_ERROR_BAD_FLAG, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_SUCCESS, Botan_FFI::ffi_guard_thunk(), 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 92 of file ffi_pk_op.cpp.

92 {
93 return BOTAN_FFI_CHECKED_DELETE(op);
94}

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 96 of file ffi_pk_op.cpp.

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

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 57 of file ffi_pk_op.cpp.

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

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.

28 {
29 if(op == nullptr) {
30 return BOTAN_FFI_ERROR_NULL_POINTER;
31 }
32
33 if(flags != 0 && flags != BOTAN_PUBKEY_DER_FORMAT_SIGNATURE) {
34 return BOTAN_FFI_ERROR_BAD_FLAG;
35 }
36
37 return ffi_guard_thunk(__func__, [=]() -> int {
38 *op = nullptr;
39
40 auto pk = std::make_unique<Botan::PK_Encryptor_EME>(safe_get(key_obj), Botan::system_rng(), padding);
41 *op = new botan_pk_op_encrypt_struct(std::move(pk));
42 return BOTAN_FFI_SUCCESS;
43 });
44}
BOTAN_PUBKEY_DER_FORMAT_SIGNATURE
#define BOTAN_PUBKEY_DER_FORMAT_SIGNATURE
Definition ffi.h:1585

References BOTAN_FFI_ERROR_BAD_FLAG, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_SUCCESS, BOTAN_PUBKEY_DER_FORMAT_SIGNATURE, Botan_FFI::ffi_guard_thunk(), 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 46 of file ffi_pk_op.cpp.

46 {
47 return BOTAN_FFI_CHECKED_DELETE(op);
48}

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 50 of file ffi_pk_op.cpp.

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

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 309 of file ffi_pk_op.cpp.

309 {
310 if(op == nullptr || padding == nullptr) {
311 return BOTAN_FFI_ERROR_NULL_POINTER;
312 }
313
314 return ffi_guard_thunk(__func__, [=]() -> int {
315 auto pk = std::make_unique<Botan::PK_KEM_Decryptor>(safe_get(key_obj), Botan::system_rng(), padding);
316 *op = new botan_pk_op_kem_decrypt_struct(std::move(pk));
317 return BOTAN_FFI_SUCCESS;
318 });
319}

References BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_SUCCESS, Botan_FFI::ffi_guard_thunk(), 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 350 of file ffi_pk_op.cpp.

350 {
351 return BOTAN_FFI_CHECKED_DELETE(op);
352}

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 334 of file ffi_pk_op.cpp.

341 {
342 return BOTAN_FFI_VISIT(op, [=](auto& kem) {
343 const auto shared_key =
344 kem.decrypt(encapsulated_key, encapsulated_key_len, desired_shared_key_len, salt, salt_len);
345
346 write_vec_output(shared_key_out, shared_key_len, shared_key);
347 });
348}

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 321 of file ffi_pk_op.cpp.

323 {
324 if(output_shared_key_length == nullptr) {
325 return BOTAN_FFI_ERROR_NULL_POINTER;
326 }
327
328 return BOTAN_FFI_VISIT(op, [=](auto& kem) {
329 *output_shared_key_length = kem.shared_key_length(desired_shared_key_length);
330 return BOTAN_FFI_SUCCESS;
331 });
332}

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 247 of file ffi_pk_op.cpp.

247 {
248 if(op == nullptr || padding == nullptr) {
249 return BOTAN_FFI_ERROR_NULL_POINTER;
250 }
251
252 return ffi_guard_thunk(__func__, [=]() -> int {
253 auto pk = std::make_unique<Botan::PK_KEM_Encryptor>(safe_get(key_obj), padding);
254 *op = new botan_pk_op_kem_encrypt_struct(std::move(pk));
255 return BOTAN_FFI_SUCCESS;
256 });
257}

References BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_SUCCESS, Botan_FFI::ffi_guard_thunk(), 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 288 of file ffi_pk_op.cpp.

296 {
297 return BOTAN_FFI_VISIT(op, [=](auto& kem) {
298 const auto result = kem.encrypt(safe_get(rng), desired_shared_key_len, {salt, salt_len});
299
300 int rc = write_vec_output(encapsulated_key_out, encapsulated_key_len, result.encapsulated_shared_key());
301
302 if(rc != 0)
303 return rc;
304
305 return write_vec_output(shared_key_out, shared_key_len, result.shared_key());
306 });
307}

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 259 of file ffi_pk_op.cpp.

259 {
260 return BOTAN_FFI_CHECKED_DELETE(op);
261}

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 276 of file ffi_pk_op.cpp.

277 {
278 if(output_encapsulated_key_length == nullptr) {
279 return BOTAN_FFI_ERROR_NULL_POINTER;
280 }
281
282 return BOTAN_FFI_VISIT(op, [=](auto& kem) {
283 *output_encapsulated_key_length = kem.encapsulated_key_length();
284 return BOTAN_FFI_SUCCESS;
285 });
286}

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 263 of file ffi_pk_op.cpp.

265 {
266 if(output_shared_key_length == nullptr) {
267 return BOTAN_FFI_ERROR_NULL_POINTER;
268 }
269
270 return BOTAN_FFI_VISIT(op, [=](auto& kem) {
271 *output_shared_key_length = kem.shared_key_length(desired_shared_key_length);
272 return BOTAN_FFI_SUCCESS;
273 });
274}

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 234 of file ffi_pk_op.cpp.

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

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 191 of file ffi_pk_op.cpp.

191 {
192 if(op == nullptr) {
193 return BOTAN_FFI_ERROR_NULL_POINTER;
194 }
195
196 if(flags != 0) {
197 return BOTAN_FFI_ERROR_BAD_FLAG;
198 }
199
200 return ffi_guard_thunk(__func__, [=]() -> int {
201 *op = nullptr;
202 auto pk = std::make_unique<Botan::PK_Key_Agreement>(safe_get(key_obj), Botan::system_rng(), kdf);
203 *op = new botan_pk_op_ka_struct(std::move(pk));
204 return BOTAN_FFI_SUCCESS;
205 });
206}

References BOTAN_FFI_ERROR_BAD_FLAG, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_SUCCESS, Botan_FFI::ffi_guard_thunk(), 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 208 of file ffi_pk_op.cpp.

208 {
209 return BOTAN_FFI_CHECKED_DELETE(op);
210}

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 212 of file ffi_pk_op.cpp.

212 {
213 return copy_view_bin(out, out_len, botan_pk_op_key_agreement_view_public, key);
214}
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 ffi_pk_op.cpp:216
Botan_FFI::copy_view_bin
int copy_view_bin(uint8_t out[], size_t *out_len, Fn fn, Args... args)
Definition ffi_util.h:163

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 225 of file ffi_pk_op.cpp.

225 {
226 return BOTAN_FFI_VISIT(op, [=](const auto& o) {
227 if(out_len == nullptr)
228 return BOTAN_FFI_ERROR_NULL_POINTER;
229 *out_len = o.agreed_value_size();
230 return BOTAN_FFI_SUCCESS;
231 });
232}

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 216 of file ffi_pk_op.cpp.

216 {
217 return BOTAN_FFI_VISIT(key, [=](const auto& k) -> int {
218 if(auto kak = dynamic_cast<const Botan::PK_Key_Agreement_Key*>(&k))
219 return invoke_view_callback(view, ctx, kak->public_value());
220 else
221 return BOTAN_FFI_ERROR_INVALID_INPUT;
222 });
223}
Botan::PK_Key_Agreement_Key
Definition pk_keys.h:376
Botan_FFI::invoke_view_callback
int invoke_view_callback(botan_view_bin_fn view, botan_view_ctx ctx, const std::vector< uint8_t, Alloc > &buf)
Definition ffi_util.h:146

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 112 of file ffi_pk_op.cpp.

112 {
113 if(op == nullptr) {
114 return BOTAN_FFI_ERROR_NULL_POINTER;
115 }
116
117 if(flags != 0 && flags != BOTAN_PUBKEY_DER_FORMAT_SIGNATURE) {
118 return BOTAN_FFI_ERROR_BAD_FLAG;
119 }
120
121 return ffi_guard_thunk(__func__, [=]() -> int {
122 *op = nullptr;
123
124 auto format = (flags & BOTAN_PUBKEY_DER_FORMAT_SIGNATURE) ? Botan::Signature_Format::DerSequence
125 : Botan::Signature_Format::Standard;
126
127 auto pk = std::make_unique<Botan::PK_Signer>(safe_get(key_obj), Botan::system_rng(), hash, format);
128 *op = new botan_pk_op_sign_struct(std::move(pk));
129 return BOTAN_FFI_SUCCESS;
130 });
131}
Botan::Signature_Format
Signature_Format
Definition pk_keys.h:31

References BOTAN_FFI_ERROR_BAD_FLAG, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_SUCCESS, BOTAN_PUBKEY_DER_FORMAT_SIGNATURE, Botan::DerSequence, Botan_FFI::ffi_guard_thunk(), 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 133 of file ffi_pk_op.cpp.

133 {
134 return BOTAN_FFI_CHECKED_DELETE(op);
135}

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 149 of file ffi_pk_op.cpp.

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

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 137 of file ffi_pk_op.cpp.

137 {
138 if(sig_len == nullptr) {
139 return BOTAN_FFI_ERROR_NULL_POINTER;
140 }
141
142 return BOTAN_FFI_VISIT(op, [=](const auto& o) { *sig_len = o.signature_length(); });
143}

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 145 of file ffi_pk_op.cpp.

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

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 153 of file ffi_pk_op.cpp.

153 {
154 if(op == nullptr) {
155 return BOTAN_FFI_ERROR_NULL_POINTER;
156 }
157
158 if(flags != 0 && flags != BOTAN_PUBKEY_DER_FORMAT_SIGNATURE) {
159 return BOTAN_FFI_ERROR_BAD_FLAG;
160 }
161
162 return ffi_guard_thunk(__func__, [=]() -> int {
163 *op = nullptr;
164 auto format = (flags & BOTAN_PUBKEY_DER_FORMAT_SIGNATURE) ? Botan::Signature_Format::DerSequence
165 : Botan::Signature_Format::Standard;
166 auto pk = std::make_unique<Botan::PK_Verifier>(safe_get(key_obj), hash, format);
167 *op = new botan_pk_op_verify_struct(std::move(pk));
168 return BOTAN_FFI_SUCCESS;
169 });
170}

References BOTAN_FFI_ERROR_BAD_FLAG, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_SUCCESS, BOTAN_PUBKEY_DER_FORMAT_SIGNATURE, Botan::DerSequence, Botan_FFI::ffi_guard_thunk(), 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 172 of file ffi_pk_op.cpp.

172 {
173 return BOTAN_FFI_CHECKED_DELETE(op);
174}

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 180 of file ffi_pk_op.cpp.

180 {
181 return BOTAN_FFI_VISIT(op, [=](auto& o) {
182 const bool legit = o.check_signature(sig, sig_len);
183
184 if(legit)
185 return BOTAN_FFI_SUCCESS;
186 else
187 return BOTAN_FFI_INVALID_VERIFIER;
188 });
189}

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 176 of file ffi_pk_op.cpp.

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

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 342 of file ffi_pkey.cpp.

342 {
343#if defined(BOTAN_HAS_HASH_ID)
344 return ffi_guard_thunk(__func__, [=]() -> int {
345 const std::vector<uint8_t> hash_id = Botan::pkcs_hash_id(hash_name);
346 return write_output(pkcs_id, pkcs_id_len, hash_id.data(), hash_id.size());
347 });
348#else
349 BOTAN_UNUSED(hash_name, pkcs_id, pkcs_id_len);
350 return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
351#endif
352}
Botan_FFI::write_output
int write_output(uint8_t out[], size_t *out_len, const uint8_t buf[], size_t buf_len)
Definition ffi_util.h:181
Botan::pkcs_hash_id
std::vector< uint8_t > pkcs_hash_id(std::string_view name)
Definition hash_id.cpp:78

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 111 of file ffi_pkey.cpp.

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

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 127 of file ffi_pkey.cpp.

127 {
128 const bool strong = (flags & BOTAN_CHECK_KEY_EXPENSIVE_TESTS);
129 return BOTAN_FFI_VISIT(key, [=](const auto& k) {
130 return (k.check_key(safe_get(rng), strong) == true) ? 0 : BOTAN_FFI_ERROR_INVALID_INPUT;
131 });
132}
BOTAN_CHECK_KEY_EXPENSIVE_TESTS
#define BOTAN_CHECK_KEY_EXPENSIVE_TESTS
Definition ffi.h:1079

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
keythe new object will be placed here
algo_namesomething like "RSA" or "ECDSA"
algo_paramsis specific to the algorithm. For RSA, specifies the modulus bit length. For ECC is the name of the curve.
rnga random number generator

Definition at line 27 of file ffi_pkey.cpp.

30 {
31 return ffi_guard_thunk(__func__, [=]() -> int {
32 if(key_obj == nullptr) {
33 return BOTAN_FFI_ERROR_NULL_POINTER;
34 }
35
36 *key_obj = nullptr;
37 if(rng_obj == nullptr) {
38 return BOTAN_FFI_ERROR_NULL_POINTER;
39 }
40
41 Botan::RandomNumberGenerator& rng = safe_get(rng_obj);
42 std::unique_ptr<Botan::Private_Key> key(
43 Botan::create_private_key(algo_name ? algo_name : "RSA", rng, algo_params ? algo_params : ""));
44
45 if(key) {
46 *key_obj = new botan_privkey_struct(std::move(key));
47 return BOTAN_FFI_SUCCESS;
48 } else {
49 return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
50 }
51 });
52}
Botan::create_private_key
std::unique_ptr< Private_Key > create_private_key(std::string_view alg_name, RandomNumberGenerator &rng, std::string_view params, std::string_view provider)
Definition pk_algs.cpp:406

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

Referenced by 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 481 of file ffi_pkey_algs.cpp.

481 {
482 return botan_privkey_create(key_obj, "DH", param_str, rng_obj);
483}
botan_privkey_create
int botan_privkey_create(botan_privkey_t *key, const char *algo_name, const char *algo_params, botan_rng_t rng)
Definition ffi_pkey.cpp:27

References botan_privkey_create().

◆ botan_privkey_create_dsa()

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

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

Parameters
keyhandler to the resulting key
rnginitialized PRNG
pbitslength of the key in bits. Must be between in range (1024, 3072) and multiple of 64. Bit size of the prime 'p'
qbitsorder of the subgroup. Must be in range (160, 256) and multiple of 8
Returns
BOTAN_FFI_SUCCESS Success, ‘key’ initialized with DSA key
BOTAN_FFI_ERROR_NULL_POINTER either ‘key’ or ‘rng’ is NULL
BOTAN_FFI_ERROR_BAD_PARAMETER unexpected value for either ‘pbits’ or ‘qbits’
BOTAN_FFI_ERROR_NOT_IMPLEMENTED functionality not implemented

Definition at line 284 of file ffi_pkey_algs.cpp.

284 {
285#if defined(BOTAN_HAS_DSA)
286
287 if((rng_obj == nullptr) || (key == nullptr)) {
288 return BOTAN_FFI_ERROR_NULL_POINTER;
289 }
290
291 if((pbits % 64) || (qbits % 8) || (pbits < 1024) || (pbits > 3072) || (qbits < 160) || (qbits > 256)) {
292 return BOTAN_FFI_ERROR_BAD_PARAMETER;
293 }
294
295 return ffi_guard_thunk(__func__, [=]() -> int {
296 Botan::RandomNumberGenerator& rng = safe_get(rng_obj);
297 Botan::DL_Group group(rng, Botan::DL_Group::Prime_Subgroup, pbits, qbits);
298 auto dsa = std::make_unique<Botan::DSA_PrivateKey>(rng, group);
299 *key = new botan_privkey_struct(std::move(dsa));
300 return BOTAN_FFI_SUCCESS;
301 });
302#else
303 BOTAN_UNUSED(key, rng_obj, pbits, qbits);
304 return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
305#endif
306}
Botan::DL_Group
Definition dl_group.h:44
Botan::DL_Group::Prime_Subgroup
@ Prime_Subgroup
Definition dl_group.h:49

References 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::DL_Group::Prime_Subgroup, and Botan_FFI::safe_get().

◆ botan_privkey_create_ecdh()

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

Definition at line 517 of file ffi_pkey_algs.cpp.

517 {
518 if(param_str == nullptr) {
519 return BOTAN_FFI_ERROR_NULL_POINTER;
520 }
521
522 const std::string params(param_str);
523
524 if(params == "curve25519") {
525 return botan_privkey_create(key_obj, "Curve25519", "", rng_obj);
526 }
527
528 if(params == "x448") {
529 return botan_privkey_create(key_obj, "X448", "", rng_obj);
530 }
531
532 return botan_privkey_create(key_obj, "ECDH", param_str, rng_obj);
533}

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 360 of file ffi_pkey_algs.cpp.

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

References botan_privkey_create().

◆ botan_privkey_create_elgamal()

int botan_privkey_create_elgamal ( 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
keyhandler to the resulting key
rnginitialized PRNG
pbitslength of the key in bits. Must be at least 1024
qbitsorder of the subgroup. Must be at least 160
Returns
BOTAN_FFI_SUCCESS Success, ‘key’ initialized with DSA key
BOTAN_FFI_ERROR_NULL_POINTER either ‘key’ or ‘rng’ is NULL
BOTAN_FFI_ERROR_BAD_PARAMETER unexpected value for either ‘pbits’ or ‘qbits’
BOTAN_FFI_ERROR_NOT_IMPLEMENTED functionality not implemented

Definition at line 422 of file ffi_pkey_algs.cpp.

422 {
423#if defined(BOTAN_HAS_ELGAMAL)
424
425 if((rng_obj == nullptr) || (key == nullptr)) {
426 return BOTAN_FFI_ERROR_NULL_POINTER;
427 }
428
429 if((pbits < 1024) || (qbits < 160)) {
430 return BOTAN_FFI_ERROR_BAD_PARAMETER;
431 }
432
433 Botan::DL_Group::PrimeType prime_type =
434 ((pbits - 1) == qbits) ? Botan::DL_Group::Strong : Botan::DL_Group::Prime_Subgroup;
435
436 return ffi_guard_thunk(__func__, [=]() -> int {
437 Botan::RandomNumberGenerator& rng = safe_get(rng_obj);
438 Botan::DL_Group group(rng, prime_type, pbits, qbits);
439 auto elg = std::make_unique<Botan::ElGamal_PrivateKey>(rng, group);
440 *key = new botan_privkey_struct(std::move(elg));
441 return BOTAN_FFI_SUCCESS;
442 });
443#else
444 BOTAN_UNUSED(key, rng_obj, pbits, qbits);
445 return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
446#endif
447}
Botan::DL_Group::PrimeType
PrimeType
Definition dl_group.h:49
Botan::DL_Group::Strong
@ Strong
Definition dl_group.h:49

References 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::DL_Group::Prime_Subgroup, Botan_FFI::safe_get(), and Botan::DL_Group::Strong.

◆ 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 1042 of file ffi_pkey_algs.cpp.

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

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 179 of file ffi_pkey_algs.cpp.

179 {
180 if(n_bits < 1024 || n_bits > 16 * 1024) {
181 return BOTAN_FFI_ERROR_BAD_PARAMETER;
182 }
183
184 std::string n_str = std::to_string(n_bits);
185
186 return botan_privkey_create(key_obj, "RSA", n_str.c_str(), rng_obj);
187}

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 79 of file ffi_pkey.cpp.

79 {
80 return BOTAN_FFI_CHECKED_DELETE(key);
81}

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 340 of file ffi_pkey_algs.cpp.

340 {
341 return botan_privkey_get_field(x, key, "x");
342}
botan_privkey_get_field
int botan_privkey_get_field(botan_mp_t output, botan_privkey_t key, const char *field_name_cstr)
Definition ffi_pkey_algs.cpp:167

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 686 of file ffi_pkey_algs.cpp.

686 {
687#if defined(BOTAN_HAS_ED25519)
688 return BOTAN_FFI_VISIT(key, [=](const auto& k) {
689 if(auto ed = dynamic_cast<const Botan::Ed25519_PrivateKey*>(&k)) {
690 const auto ed_key = ed->raw_private_key_bits();
691 if(ed_key.size() != 64)
692 return BOTAN_FFI_ERROR_INSUFFICIENT_BUFFER_SPACE;
693 Botan::copy_mem(output, ed_key.data(), ed_key.size());
694 return BOTAN_FFI_SUCCESS;
695 } else {
696 return BOTAN_FFI_ERROR_BAD_PARAMETER;
697 }
698 });
699#else
700 BOTAN_UNUSED(key, output);
701 return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
702#endif
703}
Botan::Ed25519_PrivateKey
Definition ed25519.h:65

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 754 of file ffi_pkey_algs.cpp.

754 {
755#if defined(BOTAN_HAS_ED448)
756 return BOTAN_FFI_VISIT(key, [=](const auto& k) {
757 if(auto ed = dynamic_cast<const Botan::Ed448_PrivateKey*>(&k)) {
758 const auto ed_key = ed->raw_private_key_bits();
759 Botan::copy_mem(std::span(output, 57), ed_key);
760 return BOTAN_FFI_SUCCESS;
761 } else {
762 return BOTAN_FFI_ERROR_BAD_PARAMETER;
763 }
764 });
765#else
766 BOTAN_UNUSED(key, output);
767 return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
768#endif
769}
Botan::Ed448_PrivateKey
A private key for Ed448/Ed448ph according to RFC 8032.
Definition ed448.h:81

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 154 of file ffi_pkey.cpp.

154 {
155 if(flags == BOTAN_PRIVKEY_EXPORT_FLAG_DER) {
156 return copy_view_bin(out, out_len, botan_privkey_view_der, key);
157 } else if(flags == BOTAN_PRIVKEY_EXPORT_FLAG_PEM) {
158 return copy_view_str(out, out_len, botan_privkey_view_pem, key);
159 } else {
160 return BOTAN_FFI_ERROR_BAD_FLAG;
161 }
162}
BOTAN_PRIVKEY_EXPORT_FLAG_PEM
#define BOTAN_PRIVKEY_EXPORT_FLAG_PEM
Definition ffi.h:1150
BOTAN_PRIVKEY_EXPORT_FLAG_DER
#define BOTAN_PRIVKEY_EXPORT_FLAG_DER
Definition ffi.h:1149
botan_privkey_view_der
int botan_privkey_view_der(botan_privkey_t key, botan_view_ctx ctx, botan_view_bin_fn view)
Definition ffi_pkey.cpp:164
botan_privkey_view_pem
int botan_privkey_view_pem(botan_privkey_t key, botan_view_ctx ctx, botan_view_str_fn view)
Definition ffi_pkey.cpp:169
Botan_FFI::copy_view_str
int copy_view_str(uint8_t out[], size_t *out_len, Fn fn, Args... args)
Definition ffi_util.h:171

References BOTAN_FFI_ERROR_BAD_FLAG, BOTAN_PRIVKEY_EXPORT_FLAG_DER, BOTAN_PRIVKEY_EXPORT_FLAG_PEM, botan_privkey_view_der(), botan_privkey_view_pem(), 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 174 of file ffi_pkey.cpp.

180 {
181 return botan_privkey_export_encrypted_pbkdf_iter(key, out, out_len, rng_obj, pass, 100000, nullptr, nullptr, flags);
182}
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_iter, const char *cipher, const char *pbkdf_algo, uint32_t flags)
Definition ffi_pkey.cpp:261

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 261 of file ffi_pkey.cpp.

269 {
270 if(flags == BOTAN_PRIVKEY_EXPORT_FLAG_DER) {
271 return copy_view_bin(
272 out, out_len, botan_privkey_view_encrypted_der, key, rng, passphrase, cipher, pbkdf_algo, pbkdf_iter);
273 } else if(flags == BOTAN_PRIVKEY_EXPORT_FLAG_PEM) {
274 return copy_view_str(
275 out, out_len, botan_privkey_view_encrypted_pem, key, rng, passphrase, cipher, pbkdf_algo, pbkdf_iter);
276 } else {
277 return BOTAN_FFI_ERROR_BAD_FLAG;
278 }
279}
botan_privkey_view_encrypted_der
int botan_privkey_view_encrypted_der(botan_privkey_t key, botan_rng_t rng_obj, const char *passphrase, const char *maybe_cipher, const char *maybe_pbkdf_algo, size_t maybe_pbkdf_iterations, botan_view_ctx ctx, botan_view_bin_fn view)
Definition ffi_pkey.cpp:281
botan_privkey_view_encrypted_pem
int botan_privkey_view_encrypted_pem(botan_privkey_t key, botan_rng_t rng_obj, const char *passphrase, const char *maybe_cipher, const char *maybe_pbkdf_algo, size_t maybe_pbkdf_iterations, botan_view_ctx ctx, botan_view_str_fn view)
Definition ffi_pkey.cpp:306

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 184 of file ffi_pkey.cpp.

193 {
194 if(pbkdf_iters_out) {
195 *pbkdf_iters_out = 0;
196 }
197
198 if(flags == BOTAN_PRIVKEY_EXPORT_FLAG_DER) {
199 return copy_view_bin(
200 out, out_len, botan_privkey_view_encrypted_der_timed, key, rng, passphrase, cipher, pbkdf_hash, pbkdf_msec);
201 } else if(flags == BOTAN_PRIVKEY_EXPORT_FLAG_PEM) {
202 return copy_view_str(
203 out, out_len, botan_privkey_view_encrypted_pem_timed, key, rng, passphrase, cipher, pbkdf_hash, pbkdf_msec);
204 } else {
205 return BOTAN_FFI_ERROR_BAD_FLAG;
206 }
207}
botan_privkey_view_encrypted_der_timed
int botan_privkey_view_encrypted_der_timed(botan_privkey_t key, botan_rng_t rng_obj, const char *passphrase, const char *maybe_cipher, const char *maybe_pbkdf_algo, size_t pbkdf_runtime_msec, botan_view_ctx ctx, botan_view_bin_fn view)
Definition ffi_pkey.cpp:209
botan_privkey_view_encrypted_pem_timed
int botan_privkey_view_encrypted_pem_timed(botan_privkey_t key, botan_rng_t rng_obj, const char *passphrase, const char *maybe_cipher, const char *maybe_pbkdf_algo, size_t pbkdf_runtime_msec, botan_view_ctx ctx, botan_view_str_fn view)
Definition ffi_pkey.cpp:235

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 103 of file ffi_pkey.cpp.

103 {
104 return ffi_guard_thunk(__func__, [=]() -> int {
105 auto public_key = safe_get(key_obj).public_key();
106 *pubout = new botan_pubkey_struct(std::move(public_key));
107 return BOTAN_FFI_SUCCESS;
108 });
109}

References BOTAN_FFI_SUCCESS, Botan_FFI::ffi_guard_thunk(), 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 167 of file ffi_pkey_algs.cpp.

167 {
168 if(field_name_cstr == nullptr) {
169 return BOTAN_FFI_ERROR_NULL_POINTER;
170 }
171
172 const std::string field_name(field_name_cstr);
173
174 return BOTAN_FFI_VISIT(key, [=](const auto& k) { safe_get(output) = privkey_get_field(k, field_name); });
175}

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 )

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 54 of file ffi_pkey.cpp.

55 {
56 BOTAN_UNUSED(rng_obj);
57
58 *key = nullptr;
59
60 return ffi_guard_thunk(__func__, [=]() -> int {
61 Botan::DataSource_Memory src(bits, len);
62
63 std::unique_ptr<Botan::Private_Key> pkcs8;
64
65 if(password == nullptr) {
66 pkcs8 = Botan::PKCS8::load_key(src);
67 } else {
68 pkcs8 = Botan::PKCS8::load_key(src, std::string(password));
69 }
70
71 if(pkcs8) {
72 *key = new botan_privkey_struct(std::move(pkcs8));
73 return BOTAN_FFI_SUCCESS;
74 }
75 return BOTAN_FFI_ERROR_UNKNOWN_ERROR;
76 });
77}
Botan::DataSource_Memory
Definition data_src.h:100
Botan::PKCS8::load_key
std::unique_ptr< Private_Key > load_key(DataSource &source, const std::function< std::string()> &get_pass)
Definition pkcs8.cpp:316

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

◆ 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 485 of file ffi_pkey_algs.cpp.

485 {
486#if defined(BOTAN_HAS_DIFFIE_HELLMAN)
487 *key = nullptr;
488 return ffi_guard_thunk(__func__, [=]() -> int {
489 Botan::DL_Group group(safe_get(p), safe_get(g));
490 auto dh = std::make_unique<Botan::DH_PrivateKey>(group, safe_get(x));
491 *key = new botan_privkey_struct(std::move(dh));
492 return BOTAN_FFI_SUCCESS;
493 });
494#else
495 BOTAN_UNUSED(key, p, g, x);
496 return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
497#endif
498}

References BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_SUCCESS, BOTAN_UNUSED, Botan_FFI::ffi_guard_thunk(), 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 308 of file ffi_pkey_algs.cpp.

308 {
309#if defined(BOTAN_HAS_DSA)
310 *key = nullptr;
311
312 return ffi_guard_thunk(__func__, [=]() -> int {
313 Botan::DL_Group group(safe_get(p), safe_get(q), safe_get(g));
314 auto dsa = std::make_unique<Botan::DSA_PrivateKey>(group, safe_get(x));
315 *key = new botan_privkey_struct(std::move(dsa));
316 return BOTAN_FFI_SUCCESS;
317 });
318#else
319 BOTAN_UNUSED(key, p, q, g, x);
320 return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
321#endif
322}

References BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_SUCCESS, BOTAN_UNUSED, Botan_FFI::ffi_guard_thunk(), 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 555 of file ffi_pkey_algs.cpp.

555 {
556#if defined(BOTAN_HAS_ECDH)
557 return ffi_guard_thunk(__func__, [=]() -> int {
558 std::unique_ptr<Botan::ECDH_PrivateKey> p_key;
559 int rc = privkey_load_ec(p_key, safe_get(scalar), curve_name);
560 if(rc == BOTAN_FFI_SUCCESS) {
561 *key = new botan_privkey_struct(std::move(p_key));
562 }
563 return rc;
564 });
565#else
566 BOTAN_UNUSED(key, scalar, curve_name);
567 return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
568#endif
569}

References BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_SUCCESS, BOTAN_UNUSED, Botan_FFI::ffi_guard_thunk(), 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 405 of file ffi_pkey_algs.cpp.

405 {
406#if defined(BOTAN_HAS_ECDSA)
407 return ffi_guard_thunk(__func__, [=]() -> int {
408 std::unique_ptr<Botan::ECDSA_PrivateKey> p_key;
409 int rc = privkey_load_ec(p_key, safe_get(scalar), curve_name);
410 if(rc == BOTAN_FFI_SUCCESS) {
411 *key = new botan_privkey_struct(std::move(p_key));
412 }
413 return rc;
414 });
415#else
416 BOTAN_UNUSED(key, scalar, curve_name);
417 return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
418#endif
419}

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

◆ botan_privkey_load_ed25519()

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

Definition at line 656 of file ffi_pkey_algs.cpp.

656 {
657#if defined(BOTAN_HAS_ED25519)
658 *key = nullptr;
659 return ffi_guard_thunk(__func__, [=]() -> int {
660 const Botan::secure_vector<uint8_t> privkey_vec(privkey, privkey + 32);
661 auto ed25519 = std::make_unique<Botan::Ed25519_PrivateKey>(privkey_vec);
662 *key = new botan_privkey_struct(std::move(ed25519));
663 return BOTAN_FFI_SUCCESS;
664 });
665#else
666 BOTAN_UNUSED(key, privkey);
667 return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
668#endif
669}

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

◆ botan_privkey_load_ed448()

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

Definition at line 726 of file ffi_pkey_algs.cpp.

726 {
727#if defined(BOTAN_HAS_ED448)
728 *key = nullptr;
729 return ffi_guard_thunk(__func__, [=]() -> int {
730 auto ed448 = std::make_unique<Botan::Ed448_PrivateKey>(std::span(privkey, 57));
731 *key = new botan_privkey_struct(std::move(ed448));
732 return BOTAN_FFI_SUCCESS;
733 });
734#else
735 BOTAN_UNUSED(key, privkey);
736 return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
737#endif
738}

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

◆ botan_privkey_load_elgamal()

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

Loads ElGamal private key

Parameters
keyvariable populated with key material
pprime order of a Z_p group
ggroup generator
xprivate key
Precondition
key is NULL on input
Postcondition
function allocates memory and assigns to ‘key’
Returns
0 on success, a negative value on failure

Definition at line 464 of file ffi_pkey_algs.cpp.

464 {
465#if defined(BOTAN_HAS_ELGAMAL)
466 *key = nullptr;
467 return ffi_guard_thunk(__func__, [=]() -> int {
468 Botan::DL_Group group(safe_get(p), safe_get(g));
469 auto elg = std::make_unique<Botan::ElGamal_PrivateKey>(group, safe_get(x));
470 *key = new botan_privkey_struct(std::move(elg));
471 return BOTAN_FFI_SUCCESS;
472 });
473#else
474 BOTAN_UNUSED(key, p, g, x);
475 return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
476#endif
477}

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

◆ botan_privkey_load_kyber()

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

Definition at line 926 of file ffi_pkey_algs.cpp.

926 {
927#if defined(BOTAN_HAS_KYBER)
928 *key = nullptr;
929 switch(key_len) {
930 case 1632:
931 return ffi_guard_thunk(__func__, [=]() -> int {
932 const Botan::secure_vector<uint8_t> privkey_vec(privkey, privkey + 1632);
933 auto kyber512 = std::make_unique<Botan::Kyber_PrivateKey>(privkey_vec, Botan::KyberMode::Kyber512_R3);
934 *key = new botan_privkey_struct(std::move(kyber512));
935 return BOTAN_FFI_SUCCESS;
936 });
937 case 2400:
938 return ffi_guard_thunk(__func__, [=]() -> int {
939 const Botan::secure_vector<uint8_t> privkey_vec(privkey, privkey + 2400);
940 auto kyber768 = std::make_unique<Botan::Kyber_PrivateKey>(privkey_vec, Botan::KyberMode::Kyber768_R3);
941 *key = new botan_privkey_struct(std::move(kyber768));
942 return BOTAN_FFI_SUCCESS;
943 });
944 case 3168:
945 return ffi_guard_thunk(__func__, [=]() -> int {
946 const Botan::secure_vector<uint8_t> privkey_vec(privkey, privkey + 3168);
947 auto kyber1024 = std::make_unique<Botan::Kyber_PrivateKey>(privkey_vec, Botan::KyberMode::Kyber1024_R3);
948 *key = new botan_privkey_struct(std::move(kyber1024));
949 return BOTAN_FFI_SUCCESS;
950 });
951 default:
952 BOTAN_UNUSED(key, privkey, key_len);
953 return BOTAN_FFI_ERROR_BAD_PARAMETER;
954 }
955#else
956 BOTAN_UNUSED(key, privkey);
957 return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
958#endif
959}

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

◆ 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 189 of file ffi_pkey_algs.cpp.

189 {
190#if defined(BOTAN_HAS_RSA)
191 *key = nullptr;
192
193 return ffi_guard_thunk(__func__, [=]() -> int {
194 auto rsa = std::make_unique<Botan::RSA_PrivateKey>(safe_get(rsa_p), safe_get(rsa_q), safe_get(rsa_e));
195 *key = new botan_privkey_struct(std::move(rsa));
196 return BOTAN_FFI_SUCCESS;
197 });
198#else
199 BOTAN_UNUSED(key, rsa_p, rsa_q, rsa_e);
200 return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
201#endif
202}

References BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_SUCCESS, BOTAN_UNUSED, Botan_FFI::ffi_guard_thunk(), 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 204 of file ffi_pkey_algs.cpp.

204 {
205#if defined(BOTAN_HAS_RSA)
206 *key = nullptr;
207
208 Botan::secure_vector<uint8_t> src(bits, bits + len);
209 return ffi_guard_thunk(__func__, [=]() -> int {
210 Botan::AlgorithmIdentifier alg_id("RSA", Botan::AlgorithmIdentifier::USE_NULL_PARAM);
211 auto rsa = std::make_unique<Botan::RSA_PrivateKey>(alg_id, src);
212 *key = new botan_privkey_struct(std::move(rsa));
213 return BOTAN_FFI_SUCCESS;
214 });
215#else
216 BOTAN_UNUSED(key, bits, len);
217 return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
218#endif
219}

References BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_SUCCESS, BOTAN_UNUSED, Botan_FFI::ffi_guard_thunk(), and Botan::AlgorithmIdentifier::USE_NULL_PARAM.

◆ botan_privkey_load_sm2()

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

Definition at line 626 of file ffi_pkey_algs.cpp.

626 {
627#if defined(BOTAN_HAS_SM2)
628 return ffi_guard_thunk(__func__, [=]() -> int {
629 std::unique_ptr<Botan::SM2_PrivateKey> p_key;
630 int rc = privkey_load_ec(p_key, safe_get(scalar), curve_name);
631
632 if(rc == BOTAN_FFI_SUCCESS) {
633 *key = new botan_privkey_struct(std::move(p_key));
634 }
635 return rc;
636 });
637#else
638 BOTAN_UNUSED(key, scalar, curve_name);
639 return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
640#endif
641}

References BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_SUCCESS, BOTAN_UNUSED, Botan_FFI::ffi_guard_thunk(), 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 650 of file ffi_pkey_algs.cpp.

650 {
651 return botan_privkey_load_sm2(key, scalar, curve_name);
652}
botan_privkey_load_sm2
int botan_privkey_load_sm2(botan_privkey_t *key, const botan_mp_t scalar, const char *curve_name)
Definition ffi_pkey_algs.cpp:626

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 790 of file ffi_pkey_algs.cpp.

790 {
791#if defined(BOTAN_HAS_X25519)
792 *key = nullptr;
793 return ffi_guard_thunk(__func__, [=]() -> int {
794 const Botan::secure_vector<uint8_t> privkey_vec(privkey, privkey + 32);
795 auto x25519 = std::make_unique<Botan::X25519_PrivateKey>(privkey_vec);
796 *key = new botan_privkey_struct(std::move(x25519));
797 return BOTAN_FFI_SUCCESS;
798 });
799#else
800 BOTAN_UNUSED(key, privkey);
801 return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
802#endif
803}

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

◆ botan_privkey_load_x448()

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

Definition at line 860 of file ffi_pkey_algs.cpp.

860 {
861#if defined(BOTAN_HAS_X448)
862 *key = nullptr;
863 return ffi_guard_thunk(__func__, [=]() -> int {
864 auto x448 = std::make_unique<Botan::X448_PrivateKey>(std::span(privkey, 56));
865 *key = new botan_privkey_struct(std::move(x448));
866 return BOTAN_FFI_SUCCESS;
867 });
868#else
869 BOTAN_UNUSED(key, privkey);
870 return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
871#endif
872}
Botan::x448
Point448 x448(const ScalarX448 &k, const Point448 &u)
Multiply a scalar k with a point u.
Definition x448_internal.cpp:48

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

◆ botan_privkey_rsa_get_d()

int botan_privkey_rsa_get_d ( botan_mp_t d,
botan_privkey_t rsa_key )

Definition at line 251 of file ffi_pkey_algs.cpp.

251 {
252 return botan_privkey_get_field(d, key, "d");
253}

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 247 of file ffi_pkey_algs.cpp.

247 {
248 return botan_privkey_get_field(e, key, "e");
249}

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 243 of file ffi_pkey_algs.cpp.

243 {
244 return botan_privkey_get_field(n, key, "n");
245}

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 235 of file ffi_pkey_algs.cpp.

235 {
236 return botan_privkey_get_field(p, key, "p");
237}

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 263 of file ffi_pkey_algs.cpp.

263 {
264#if defined(BOTAN_HAS_RSA)
265 return BOTAN_FFI_VISIT(rsa_key, [=](const auto& k) -> int {
266 if(const Botan::RSA_PrivateKey* rsa = dynamic_cast<const Botan::RSA_PrivateKey*>(&k)) {
267 if(flags == BOTAN_PRIVKEY_EXPORT_FLAG_DER)
268 return write_vec_output(out, out_len, rsa->private_key_bits());
269 else if(flags == BOTAN_PRIVKEY_EXPORT_FLAG_PEM)
270 return write_str_output(out, out_len, Botan::PEM_Code::encode(rsa->private_key_bits(), "RSA PRIVATE KEY"));
271 else
272 return BOTAN_FFI_ERROR_BAD_FLAG;
273 } else {
274 return BOTAN_FFI_ERROR_BAD_PARAMETER;
275 }
276 });
277#else
278 BOTAN_UNUSED(rsa_key, out, out_len, flags);
279 return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
280#endif
281}
Botan::RSA_PrivateKey
Definition rsa.h:100
Botan::PEM_Code::encode
std::string encode(const uint8_t der[], size_t length, std::string_view label, size_t width)
Definition pem.cpp:39

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 239 of file ffi_pkey_algs.cpp.

239 {
240 return botan_privkey_get_field(q, key, "q");
241}

References botan_privkey_get_field().

◆ 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 164 of file ffi_pkey.cpp.

164 {
165 return BOTAN_FFI_VISIT(
166 key, [=](const auto& k) -> int { return invoke_view_callback(view, ctx, Botan::PKCS8::BER_encode(k)); });
167}
Botan::PKCS8::BER_encode
std::vector< uint8_t > BER_encode(const Private_Key &key, RandomNumberGenerator &rng, std::string_view pass, std::chrono::milliseconds msec, std::string_view pbe_algo)
Definition pkcs8.cpp:163

References Botan::PKCS8::BER_encode(), 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 281 of file ffi_pkey.cpp.

288 {
289 if(passphrase == nullptr) {
290 return BOTAN_FFI_ERROR_NULL_POINTER;
291 }
292
293 return BOTAN_FFI_VISIT(key, [=](const auto& k) {
294 Botan::RandomNumberGenerator& rng = safe_get(rng_obj);
295
296 const std::string cipher = (maybe_cipher ? maybe_cipher : "");
297 const std::string pbkdf_algo = (maybe_pbkdf_algo ? maybe_pbkdf_algo : "");
298 const size_t pbkdf_iter = (maybe_pbkdf_iterations ? maybe_pbkdf_iterations : 100000);
299
300 auto pkcs8 = Botan::PKCS8::BER_encode_encrypted_pbkdf_iter(k, rng, passphrase, pbkdf_iter, cipher, pbkdf_algo);
301
302 return invoke_view_callback(view, ctx, pkcs8);
303 });
304}
Botan::PKCS8::BER_encode_encrypted_pbkdf_iter
std::vector< uint8_t > BER_encode_encrypted_pbkdf_iter(const Private_Key &key, RandomNumberGenerator &rng, std::string_view pass, size_t pbkdf_iterations, std::string_view cipher, std::string_view pbkdf_hash)
Definition pkcs8.cpp:203

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 209 of file ffi_pkey.cpp.

216 {
217 if(passphrase == nullptr) {
218 return BOTAN_FFI_ERROR_NULL_POINTER;
219 }
220
221 return BOTAN_FFI_VISIT(key, [=](const auto& k) {
222 const std::chrono::milliseconds pbkdf_time(pbkdf_runtime_msec);
223 Botan::RandomNumberGenerator& rng = safe_get(rng_obj);
224
225 const std::string cipher = (maybe_cipher ? maybe_cipher : "");
226 const std::string pbkdf_algo = (maybe_pbkdf_algo ? maybe_pbkdf_algo : "");
227
228 auto pkcs8 =
229 Botan::PKCS8::BER_encode_encrypted_pbkdf_msec(k, rng, passphrase, pbkdf_time, nullptr, cipher, pbkdf_algo);
230
231 return invoke_view_callback(view, ctx, pkcs8);
232 });
233}
Botan::PKCS8::BER_encode_encrypted_pbkdf_msec
std::vector< uint8_t > BER_encode_encrypted_pbkdf_msec(const Private_Key &key, RandomNumberGenerator &rng, std::string_view pass, std::chrono::milliseconds pbkdf_msec, size_t *pbkdf_iterations, std::string_view cipher, std::string_view pbkdf_hash)
Definition pkcs8.cpp:246

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 306 of file ffi_pkey.cpp.

313 {
314 if(passphrase == nullptr) {
315 return BOTAN_FFI_ERROR_NULL_POINTER;
316 }
317
318 return BOTAN_FFI_VISIT(key, [=](const auto& k) {
319 Botan::RandomNumberGenerator& rng = safe_get(rng_obj);
320
321 const std::string cipher = (maybe_cipher ? maybe_cipher : "");
322 const std::string pbkdf_algo = (maybe_pbkdf_algo ? maybe_pbkdf_algo : "");
323 const size_t pbkdf_iter = (maybe_pbkdf_iterations ? maybe_pbkdf_iterations : 100000);
324
325 auto pkcs8 = Botan::PKCS8::PEM_encode_encrypted_pbkdf_iter(k, rng, passphrase, pbkdf_iter, cipher, pbkdf_algo);
326
327 return invoke_view_callback(view, ctx, pkcs8);
328 });
329}
Botan::PKCS8::PEM_encode_encrypted_pbkdf_iter
std::string PEM_encode_encrypted_pbkdf_iter(const Private_Key &key, RandomNumberGenerator &rng, std::string_view pass, size_t pbkdf_iterations, std::string_view cipher, std::string_view pbkdf_hash)
Definition pkcs8.cpp:233

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 235 of file ffi_pkey.cpp.

242 {
243 if(passphrase == nullptr) {
244 return BOTAN_FFI_ERROR_NULL_POINTER;
245 }
246
247 return BOTAN_FFI_VISIT(key, [=](const auto& k) {
248 const std::chrono::milliseconds pbkdf_time(pbkdf_runtime_msec);
249 Botan::RandomNumberGenerator& rng = safe_get(rng_obj);
250
251 const std::string cipher = (maybe_cipher ? maybe_cipher : "");
252 const std::string pbkdf_algo = (maybe_pbkdf_algo ? maybe_pbkdf_algo : "");
253
254 auto pkcs8 =
255 Botan::PKCS8::PEM_encode_encrypted_pbkdf_msec(k, rng, passphrase, pbkdf_time, nullptr, cipher, pbkdf_algo);
256
257 return invoke_view_callback(view, ctx, pkcs8);
258 });
259}
Botan::PKCS8::PEM_encode_encrypted_pbkdf_msec
std::string PEM_encode_encrypted_pbkdf_msec(const Private_Key &key, RandomNumberGenerator &rng, std::string_view pass, std::chrono::milliseconds pbkdf_msec, size_t *pbkdf_iterations, std::string_view cipher, std::string_view pbkdf_hash)
Definition pkcs8.cpp:280

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 996 of file ffi_pkey_algs.cpp.

996 {
997#if defined(BOTAN_HAS_KYBER)
998 return BOTAN_FFI_VISIT(key, [=](const auto& k) -> int {
999 if(auto kyber = dynamic_cast<const Botan::Kyber_PrivateKey*>(&k)) {
1000 return invoke_view_callback(view, ctx, kyber->raw_private_key_bits());
1001 } else {
1002 return BOTAN_FFI_ERROR_BAD_PARAMETER;
1003 }
1004 });
1005#else
1006 BOTAN_UNUSED(key, ctx, view);
1007 return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
1008#endif
1009}
Botan::Kyber_PrivateKey
Definition kyber.h:132

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 169 of file ffi_pkey.cpp.

169 {
170 return BOTAN_FFI_VISIT(
171 key, [=](const auto& k) -> int { return invoke_view_callback(view, ctx, Botan::PKCS8::PEM_encode(k)); });
172}
Botan::PKCS8::PEM_encode
std::string PEM_encode(const Private_Key &key)
Definition pkcs8.cpp:118

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

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 820 of file ffi_pkey_algs.cpp.

820 {
821#if defined(BOTAN_HAS_X25519)
822 return BOTAN_FFI_VISIT(key, [=](const auto& k) {
823 if(auto x25519 = dynamic_cast<const Botan::X25519_PrivateKey*>(&k)) {
824 const auto x25519_key = x25519->raw_private_key_bits();
825 if(x25519_key.size() != 32)
826 return BOTAN_FFI_ERROR_INSUFFICIENT_BUFFER_SPACE;
827 Botan::copy_mem(output, x25519_key.data(), x25519_key.size());
828 return BOTAN_FFI_SUCCESS;
829 } else {
830 return BOTAN_FFI_ERROR_BAD_PARAMETER;
831 }
832 });
833#else
834 BOTAN_UNUSED(key, output);
835 return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
836#endif
837}
Botan::Curve25519_PrivateKey
Definition curve25519.h:64

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 888 of file ffi_pkey_algs.cpp.

888 {
889#if defined(BOTAN_HAS_X448)
890 return BOTAN_FFI_VISIT(key, [=](const auto& k) {
891 if(auto x448 = dynamic_cast<const Botan::X448_PrivateKey*>(&k)) {
892 const auto x448_key = x448->raw_private_key_bits();
893 Botan::copy_mem(std::span(output, 56), x448_key);
894 return BOTAN_FFI_SUCCESS;
895 } else {
896 return BOTAN_FFI_ERROR_BAD_PARAMETER;
897 }
898 });
899#else
900 BOTAN_UNUSED(key, output);
901 return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
902#endif
903}
Botan::X448_PrivateKey
A private key for the X448 key agreement scheme according to RFC 7748.
Definition x448.h:65

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 115 of file ffi_pkey.cpp.

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

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 119 of file ffi_pkey.cpp.

119 {
120 const bool strong = (flags & BOTAN_CHECK_KEY_EXPENSIVE_TESTS);
121
122 return BOTAN_FFI_VISIT(key, [=](const auto& k) {
123 return (k.check_key(safe_get(rng), strong) == true) ? 0 : BOTAN_FFI_ERROR_INVALID_INPUT;
124 });
125}

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 99 of file ffi_pkey.cpp.

99 {
100 return BOTAN_FFI_CHECKED_DELETE(key);
101}

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 352 of file ffi_pkey_algs.cpp.

352 {
353 return botan_pubkey_get_field(g, key, "g");
354}
botan_pubkey_get_field
int botan_pubkey_get_field(botan_mp_t output, botan_pubkey_t key, const char *field_name_cstr)
Definition ffi_pkey_algs.cpp:157

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 344 of file ffi_pkey_algs.cpp.

344 {
345 return botan_pubkey_get_field(p, key, "p");
346}

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 348 of file ffi_pkey_algs.cpp.

348 {
349 return botan_pubkey_get_field(q, key, "q");
350}

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 356 of file ffi_pkey_algs.cpp.

356 {
357 return botan_pubkey_get_field(y, key, "y");
358}

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 366 of file ffi_pkey_algs.cpp.

366 {
367#if defined(BOTAN_HAS_ECC_KEY)
368 return ffi_guard_thunk(__func__, [=]() -> int {
369 const Botan::Public_Key& pub_key = safe_get(key);
370 const Botan::EC_PublicKey* ec_key = dynamic_cast<const Botan::EC_PublicKey*>(&pub_key);
371
372 if(ec_key == nullptr) {
373 return BOTAN_FFI_ERROR_BAD_PARAMETER;
374 }
375
376 return ec_key->domain().used_explicit_encoding() ? 1 : 0;
377 });
378#else
379 BOTAN_UNUSED(key);
380 return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
381#endif
382}
Botan::EC_Group::used_explicit_encoding
bool used_explicit_encoding() const
Definition ec_group.h:359
Botan::EC_PublicKey
Definition ecc_key.h:28
Botan::EC_PublicKey::domain
const EC_Group & domain() const
Definition ecc_key.h:54
Botan::Public_Key
Definition pk_keys.h:119

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 705 of file ffi_pkey_algs.cpp.

705 {
706#if defined(BOTAN_HAS_ED25519)
707 return BOTAN_FFI_VISIT(key, [=](const auto& k) {
708 if(auto ed = dynamic_cast<const Botan::Ed25519_PublicKey*>(&k)) {
709 const std::vector<uint8_t>& ed_key = ed->get_public_key();
710 if(ed_key.size() != 32)
711 return BOTAN_FFI_ERROR_INSUFFICIENT_BUFFER_SPACE;
712 Botan::copy_mem(output, ed_key.data(), ed_key.size());
713 return BOTAN_FFI_SUCCESS;
714 } else {
715 return BOTAN_FFI_ERROR_BAD_PARAMETER;
716 }
717 });
718#else
719 BOTAN_UNUSED(key, output);
720 return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
721#endif
722}
Botan::Ed25519_PublicKey
Definition ed25519.h:18

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 771 of file ffi_pkey_algs.cpp.

771 {
772#if defined(BOTAN_HAS_ED448)
773 return BOTAN_FFI_VISIT(key, [=](const auto& k) {
774 if(auto ed = dynamic_cast<const Botan::Ed448_PublicKey*>(&k)) {
775 const auto ed_key = ed->public_key_bits();
776 Botan::copy_mem(std::span(output, 57), ed_key);
777 return BOTAN_FFI_SUCCESS;
778 } else {
779 return BOTAN_FFI_ERROR_BAD_PARAMETER;
780 }
781 });
782#else
783 BOTAN_UNUSED(key, output);
784 return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
785#endif
786}
Botan::Ed448_PublicKey
A public key for Ed448/Ed448ph according to RFC 8032.
Definition ed448.h:27

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 331 of file ffi_pkey.cpp.

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

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 134 of file ffi_pkey.cpp.

134 {
135 if(flags == BOTAN_PRIVKEY_EXPORT_FLAG_DER) {
136 return copy_view_bin(out, out_len, botan_pubkey_view_der, key);
137 } else if(flags == BOTAN_PRIVKEY_EXPORT_FLAG_PEM) {
138 return copy_view_str(out, out_len, botan_pubkey_view_pem, key);
139 } else {
140 return BOTAN_FFI_ERROR_BAD_FLAG;
141 }
142}
botan_pubkey_view_pem
int botan_pubkey_view_pem(botan_pubkey_t key, botan_view_ctx ctx, botan_view_str_fn view)
Definition ffi_pkey.cpp:149
botan_pubkey_view_der
int botan_pubkey_view_der(botan_pubkey_t key, botan_view_ctx ctx, botan_view_bin_fn view)
Definition ffi_pkey.cpp:144

References BOTAN_FFI_ERROR_BAD_FLAG, BOTAN_PRIVKEY_EXPORT_FLAG_DER, BOTAN_PRIVKEY_EXPORT_FLAG_PEM, botan_pubkey_view_der(), botan_pubkey_view_pem(), 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 335 of file ffi_pkey.cpp.

335 {
336 return BOTAN_FFI_VISIT(key, [=](const auto& k) {
337 auto h = Botan::HashFunction::create_or_throw(hash_fn);
338 return write_vec_output(out, out_len, h->process(k.public_key_bits()));
339 });
340}
Botan::HashFunction::create_or_throw
static std::unique_ptr< HashFunction > create_or_throw(std::string_view algo_spec, std::string_view provider="")
Definition hash.cpp:298

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 157 of file ffi_pkey_algs.cpp.

157 {
158 if(field_name_cstr == nullptr) {
159 return BOTAN_FFI_ERROR_NULL_POINTER;
160 }
161
162 const std::string field_name(field_name_cstr);
163
164 return BOTAN_FFI_VISIT(key, [=](const auto& k) { safe_get(output) = pubkey_get_field(k, field_name); });
165}

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 83 of file ffi_pkey.cpp.

83 {
84 *key = nullptr;
85
86 return ffi_guard_thunk(__func__, [=]() -> int {
87 Botan::DataSource_Memory src(bits, bits_len);
88 std::unique_ptr<Botan::Public_Key> pubkey(Botan::X509::load_key(src));
89
90 if(pubkey == nullptr) {
91 return BOTAN_FFI_ERROR_UNKNOWN_ERROR;
92 }
93
94 *key = new botan_pubkey_struct(std::move(pubkey));
95 return BOTAN_FFI_SUCCESS;
96 });
97}
Botan::X509::load_key
std::unique_ptr< Public_Key > load_key(DataSource &source)
Definition x509_key.cpp:28

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

◆ botan_pubkey_load_dh()

int botan_pubkey_load_dh ( botan_pubkey_t * key,
botan_mp_t p,
botan_mp_t g,
botan_mp_t y )

Loads Diffie Hellman public key

Parameters
keyvariable populated with key material
pprime order of a Z_p group
ggroup generator
ypublic key
Precondition
key is NULL on input
Postcondition
function allocates memory and assigns to ‘key’
Returns
0 on success, a negative value on failure

Definition at line 500 of file ffi_pkey_algs.cpp.

500 {
501#if defined(BOTAN_HAS_DIFFIE_HELLMAN)
502 *key = nullptr;
503 return ffi_guard_thunk(__func__, [=]() -> int {
504 Botan::DL_Group group(safe_get(p), safe_get(g));
505 auto dh = std::make_unique<Botan::DH_PublicKey>(group, safe_get(y));
506 *key = new botan_pubkey_struct(std::move(dh));
507 return BOTAN_FFI_SUCCESS;
508 });
509#else
510 BOTAN_UNUSED(key, p, g, y);
511 return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
512#endif
513}

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

◆ 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 324 of file ffi_pkey_algs.cpp.

324 {
325#if defined(BOTAN_HAS_DSA)
326 *key = nullptr;
327
328 return ffi_guard_thunk(__func__, [=]() -> int {
329 Botan::DL_Group group(safe_get(p), safe_get(q), safe_get(g));
330 auto dsa = std::make_unique<Botan::DSA_PublicKey>(group, safe_get(y));
331 *key = new botan_pubkey_struct(std::move(dsa));
332 return BOTAN_FFI_SUCCESS;
333 });
334#else
335 BOTAN_UNUSED(key, p, q, g, y);
336 return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
337#endif
338}

References BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_SUCCESS, BOTAN_UNUSED, Botan_FFI::ffi_guard_thunk(), 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 535 of file ffi_pkey_algs.cpp.

538 {
539#if defined(BOTAN_HAS_ECDH)
540 return ffi_guard_thunk(__func__, [=]() -> int {
541 std::unique_ptr<Botan::ECDH_PublicKey> p_key;
542 int rc = pubkey_load_ec(p_key, safe_get(public_x), safe_get(public_y), curve_name);
543
544 if(rc == BOTAN_FFI_SUCCESS) {
545 *key = new botan_pubkey_struct(std::move(p_key));
546 }
547 return rc;
548 });
549#else
550 BOTAN_UNUSED(key, public_x, public_y, curve_name);
551 return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
552#endif
553}

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

◆ 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 384 of file ffi_pkey_algs.cpp.

387 {
388#if defined(BOTAN_HAS_ECDSA)
389 return ffi_guard_thunk(__func__, [=]() -> int {
390 std::unique_ptr<Botan::ECDSA_PublicKey> p_key;
391
392 int rc = pubkey_load_ec(p_key, safe_get(public_x), safe_get(public_y), curve_name);
393 if(rc == BOTAN_FFI_SUCCESS) {
394 *key = new botan_pubkey_struct(std::move(p_key));
395 }
396
397 return rc;
398 });
399#else
400 BOTAN_UNUSED(key, public_x, public_y, curve_name);
401 return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
402#endif
403}

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

◆ botan_pubkey_load_ed25519()

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

Definition at line 671 of file ffi_pkey_algs.cpp.

671 {
672#if defined(BOTAN_HAS_ED25519)
673 *key = nullptr;
674 return ffi_guard_thunk(__func__, [=]() -> int {
675 const std::vector<uint8_t> pubkey_vec(pubkey, pubkey + 32);
676 auto ed25519 = std::make_unique<Botan::Ed25519_PublicKey>(pubkey_vec);
677 *key = new botan_pubkey_struct(std::move(ed25519));
678 return BOTAN_FFI_SUCCESS;
679 });
680#else
681 BOTAN_UNUSED(key, pubkey);
682 return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
683#endif
684}

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

◆ botan_pubkey_load_ed448()

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

Definition at line 740 of file ffi_pkey_algs.cpp.

740 {
741#if defined(BOTAN_HAS_ED448)
742 *key = nullptr;
743 return ffi_guard_thunk(__func__, [=]() -> int {
744 auto ed448 = std::make_unique<Botan::Ed448_PublicKey>(std::span(pubkey, 57));
745 *key = new botan_pubkey_struct(std::move(ed448));
746 return BOTAN_FFI_SUCCESS;
747 });
748#else
749 BOTAN_UNUSED(key, pubkey);
750 return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
751#endif
752}

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

◆ botan_pubkey_load_elgamal()

int botan_pubkey_load_elgamal ( botan_pubkey_t * key,
botan_mp_t p,
botan_mp_t g,
botan_mp_t y )

Loads ElGamal public key

Parameters
keyvariable populated with key material
pprime order of a Z_p group
ggroup generator
ypublic key
Precondition
key is NULL on input
Postcondition
function allocates memory and assigns to ‘key’
Returns
0 on success, a negative value on failure

Definition at line 449 of file ffi_pkey_algs.cpp.

449 {
450#if defined(BOTAN_HAS_ELGAMAL)
451 *key = nullptr;
452 return ffi_guard_thunk(__func__, [=]() -> int {
453 Botan::DL_Group group(safe_get(p), safe_get(g));
454 auto elg = std::make_unique<Botan::ElGamal_PublicKey>(group, safe_get(y));
455 *key = new botan_pubkey_struct(std::move(elg));
456 return BOTAN_FFI_SUCCESS;
457 });
458#else
459 BOTAN_UNUSED(key, p, g, y);
460 return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
461#endif
462}

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

◆ botan_pubkey_load_kyber()

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

Definition at line 961 of file ffi_pkey_algs.cpp.

961 {
962#if defined(BOTAN_HAS_KYBER)
963 *key = nullptr;
964 switch(key_len) {
965 case 800:
966 return ffi_guard_thunk(__func__, [=]() -> int {
967 const std::vector<uint8_t> pubkey_vec(pubkey, pubkey + 800);
968 auto kyber512 = std::make_unique<Botan::Kyber_PublicKey>(pubkey_vec, Botan::KyberMode::Kyber512_R3);
969 *key = new botan_pubkey_struct(std::move(kyber512));
970 return BOTAN_FFI_SUCCESS;
971 });
972 case 1184:
973 return ffi_guard_thunk(__func__, [=]() -> int {
974 const std::vector<uint8_t> pubkey_vec(pubkey, pubkey + 1184);
975 auto kyber768 = std::make_unique<Botan::Kyber_PublicKey>(pubkey_vec, Botan::KyberMode::Kyber768_R3);
976 *key = new botan_pubkey_struct(std::move(kyber768));
977 return BOTAN_FFI_SUCCESS;
978 });
979 case 1568:
980 return ffi_guard_thunk(__func__, [=]() -> int {
981 const std::vector<uint8_t> pubkey_vec(pubkey, pubkey + 1568);
982 auto kyber1024 = std::make_unique<Botan::Kyber_PublicKey>(pubkey_vec, Botan::KyberMode::Kyber1024_R3);
983 *key = new botan_pubkey_struct(std::move(kyber1024));
984 return BOTAN_FFI_SUCCESS;
985 });
986 default:
987 BOTAN_UNUSED(key, pubkey, key_len);
988 return BOTAN_FFI_ERROR_BAD_PARAMETER;
989 }
990#else
991 BOTAN_UNUSED(key, pubkey, key_len);
992 return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
993#endif
994}

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

◆ botan_pubkey_load_rsa()

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

Definition at line 221 of file ffi_pkey_algs.cpp.

221 {
222#if defined(BOTAN_HAS_RSA)
223 *key = nullptr;
224 return ffi_guard_thunk(__func__, [=]() -> int {
225 auto rsa = std::make_unique<Botan::RSA_PublicKey>(safe_get(n), safe_get(e));
226 *key = new botan_pubkey_struct(std::move(rsa));
227 return BOTAN_FFI_SUCCESS;
228 });
229#else
230 BOTAN_UNUSED(key, n, e);
231 return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
232#endif
233}

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

◆ 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 607 of file ffi_pkey_algs.cpp.

610 {
611#if defined(BOTAN_HAS_SM2)
612 return ffi_guard_thunk(__func__, [=]() -> int {
613 std::unique_ptr<Botan::SM2_PublicKey> p_key;
614 if(!pubkey_load_ec(p_key, safe_get(public_x), safe_get(public_y), curve_name)) {
615 *key = new botan_pubkey_struct(std::move(p_key));
616 return BOTAN_FFI_SUCCESS;
617 }
618 return BOTAN_FFI_ERROR_UNKNOWN_ERROR;
619 });
620#else
621 BOTAN_UNUSED(key, public_x, public_y, curve_name);
622 return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
623#endif
624}

References BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_UNKNOWN_ERROR, BOTAN_FFI_SUCCESS, BOTAN_UNUSED, Botan_FFI::ffi_guard_thunk(), 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 643 of file ffi_pkey_algs.cpp.

646 {
647 return botan_pubkey_load_sm2(key, public_x, public_y, curve_name);
648}
botan_pubkey_load_sm2
int botan_pubkey_load_sm2(botan_pubkey_t *key, const botan_mp_t public_x, const botan_mp_t public_y, const char *curve_name)
Definition ffi_pkey_algs.cpp:607

References botan_pubkey_load_sm2().

◆ botan_pubkey_load_x25519()

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

Definition at line 805 of file ffi_pkey_algs.cpp.

805 {
806#if defined(BOTAN_HAS_X25519)
807 *key = nullptr;
808 return ffi_guard_thunk(__func__, [=]() -> int {
809 const std::vector<uint8_t> pubkey_vec(pubkey, pubkey + 32);
810 auto x25519 = std::make_unique<Botan::X25519_PublicKey>(pubkey_vec);
811 *key = new botan_pubkey_struct(std::move(x25519));
812 return BOTAN_FFI_SUCCESS;
813 });
814#else
815 BOTAN_UNUSED(key, pubkey);
816 return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
817#endif
818}

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

◆ botan_pubkey_load_x448()

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

Definition at line 874 of file ffi_pkey_algs.cpp.

874 {
875#if defined(BOTAN_HAS_X448)
876 *key = nullptr;
877 return ffi_guard_thunk(__func__, [=]() -> int {
878 auto x448 = std::make_unique<Botan::X448_PublicKey>(std::span(pubkey, 56));
879 *key = new botan_pubkey_struct(std::move(x448));
880 return BOTAN_FFI_SUCCESS;
881 });
882#else
883 BOTAN_UNUSED(key, pubkey);
884 return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
885#endif
886}

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

◆ botan_pubkey_rsa_get_e()

int botan_pubkey_rsa_get_e ( botan_mp_t e,
botan_pubkey_t rsa_key )

Definition at line 255 of file ffi_pkey_algs.cpp.

255 {
256 return botan_pubkey_get_field(e, key, "e");
257}

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 259 of file ffi_pkey_algs.cpp.

259 {
260 return botan_pubkey_get_field(n, key, "n");
261}

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 573 of file ffi_pkey_algs.cpp.

574 {
575 if(out == nullptr || out_len == nullptr) {
576 return BOTAN_FFI_ERROR_NULL_POINTER;
577 }
578 if(ident == nullptr || hash_algo == nullptr || key == nullptr) {
579 return BOTAN_FFI_ERROR_NULL_POINTER;
580 }
581
582#if defined(BOTAN_HAS_SM2)
583 return ffi_guard_thunk(__func__, [=]() -> int {
584 const Botan::Public_Key& pub_key = safe_get(key);
585 const Botan::EC_PublicKey* ec_key = dynamic_cast<const Botan::EC_PublicKey*>(&pub_key);
586
587 if(ec_key == nullptr) {
588 return BOTAN_FFI_ERROR_BAD_PARAMETER;
589 }
590
591 if(ec_key->algo_name() != "SM2") {
592 return BOTAN_FFI_ERROR_BAD_PARAMETER;
593 }
594
595 const std::string ident_str(ident);
596 std::unique_ptr<Botan::HashFunction> hash = Botan::HashFunction::create_or_throw(hash_algo);
597
598 const std::vector<uint8_t> za = Botan::sm2_compute_za(*hash, ident_str, ec_key->domain(), ec_key->public_point());
599
600 return write_vec_output(out, out_len, za);
601 });
602#else
603 return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
604#endif
605}
Botan::Asymmetric_Key::algo_name
virtual std::string algo_name() const =0
Botan::EC_PublicKey::public_point
const EC_Point & public_point() const
Definition ecc_key.h:40
Botan::sm2_compute_za
std::vector< uint8_t > sm2_compute_za(HashFunction &hash, std::string_view user_id, const EC_Group &domain, const EC_Point &pubkey)
Definition sm2.cpp:58

References 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::EC_PublicKey::public_point(), 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 144 of file ffi_pkey.cpp.

144 {
145 return BOTAN_FFI_VISIT(
146 key, [=](const auto& k) -> int { return invoke_view_callback(view, ctx, Botan::X509::BER_encode(k)); });
147}
Botan::X509::BER_encode
std::vector< uint8_t > BER_encode(const Public_Key &key)
Definition x509_key.h:23

References Botan::X509::BER_encode(), 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 1026 of file ffi_pkey_algs.cpp.

1026 {
1027#if defined(BOTAN_HAS_ECC_PUBLIC_KEY_CRYPTO)
1028 return BOTAN_FFI_VISIT(key, [=](const auto& k) -> int {
1029 if(auto ecc = dynamic_cast<const Botan::EC_PublicKey*>(&k)) {
1030 auto pt = ecc->public_point().encode(Botan::EC_Point_Format::Uncompressed);
1031 return invoke_view_callback(view, ctx, pt);
1032 } else {
1033 return BOTAN_FFI_ERROR_BAD_PARAMETER;
1034 }
1035 });
1036#else
1037 BOTAN_UNUSED(key, view, ctx);
1038 return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
1039#endif
1040}

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

◆ 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 1011 of file ffi_pkey_algs.cpp.

1011 {
1012#if defined(BOTAN_HAS_KYBER)
1013 return BOTAN_FFI_VISIT(key, [=](const auto& k) -> int {
1014 if(auto kyber = dynamic_cast<const Botan::Kyber_PublicKey*>(&k)) {
1015 return invoke_view_callback(view, ctx, kyber->public_key_bits());
1016 } else {
1017 return BOTAN_FFI_ERROR_BAD_PARAMETER;
1018 }
1019 });
1020#else
1021 BOTAN_UNUSED(key, ctx, view);
1022 return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
1023#endif
1024}
Botan::Kyber_PublicKey
Definition kyber.h:75

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 149 of file ffi_pkey.cpp.

149 {
150 return BOTAN_FFI_VISIT(
151 key, [=](const auto& k) -> int { return invoke_view_callback(view, ctx, Botan::X509::PEM_encode(k)); });
152}
Botan::X509::PEM_encode
std::string PEM_encode(const Public_Key &key)
Definition x509_key.cpp:21

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

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 839 of file ffi_pkey_algs.cpp.

839 {
840#if defined(BOTAN_HAS_X25519)
841 return BOTAN_FFI_VISIT(key, [=](const auto& k) {
842 if(auto x25519 = dynamic_cast<const Botan::X25519_PublicKey*>(&k)) {
843 const std::vector<uint8_t>& x25519_key = x25519->public_value();
844 if(x25519_key.size() != 32)
845 return BOTAN_FFI_ERROR_INSUFFICIENT_BUFFER_SPACE;
846 Botan::copy_mem(output, x25519_key.data(), x25519_key.size());
847 return BOTAN_FFI_SUCCESS;
848 } else {
849 return BOTAN_FFI_ERROR_BAD_PARAMETER;
850 }
851 });
852#else
853 BOTAN_UNUSED(key, output);
854 return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
855#endif
856}
Botan::Curve25519_PublicKey
Definition curve25519.h:15

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_x448_get_pubkey()

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

Definition at line 905 of file ffi_pkey_algs.cpp.

905 {
906#if defined(BOTAN_HAS_X448)
907 return BOTAN_FFI_VISIT(key, [=](const auto& k) {
908 if(auto x448 = dynamic_cast<const Botan::X448_PublicKey*>(&k)) {
909 const std::vector<uint8_t>& x448_key = x448->public_value();
910 Botan::copy_mem(std::span(output, 56), x448_key);
911 return BOTAN_FFI_SUCCESS;
912 } else {
913 return BOTAN_FFI_ERROR_BAD_PARAMETER;
914 }
915 });
916#else
917 BOTAN_UNUSED(key, output);
918 return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
919#endif
920}
Botan::X448_PublicKey
A public key for the X448 key agreement scheme according to RFC 7748.
Definition x448.h:19

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.

62 {
63 if(algo == nullptr || password == nullptr) {
64 return BOTAN_FFI_ERROR_NULL_POINTER;
65 }
66
67 if(password_len == 0) {
68 password_len = std::strlen(password);
69 }
70
71 return ffi_guard_thunk(__func__, [=]() -> int {
72 auto pwdhash_fam = Botan::PasswordHashFamily::create(algo);
73
74 if(!pwdhash_fam) {
75 return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
76 }
77
78 auto pwdhash = pwdhash_fam->from_params(param1, param2, param3);
79
80 pwdhash->derive_key(out, out_len, password, password_len, salt, salt_len);
81
82 return BOTAN_FFI_SUCCESS;
83 });
84}
Botan::PasswordHashFamily::create
static std::unique_ptr< PasswordHashFamily > create(std::string_view algo_spec, std::string_view provider="")
Definition pwdhash.cpp:53

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.

96 {
97 if(algo == nullptr || password == nullptr) {
98 return BOTAN_FFI_ERROR_NULL_POINTER;
99 }
100
101 if(password_len == 0) {
102 password_len = std::strlen(password);
103 }
104
105 return ffi_guard_thunk(__func__, [=]() -> int {
106 auto pwdhash_fam = Botan::PasswordHashFamily::create(algo);
107
108 if(!pwdhash_fam) {
109 return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
110 }
111
112 auto pwdhash = pwdhash_fam->tune(out_len, std::chrono::milliseconds(msec));
113
114 if(param1) {
115 *param1 = pwdhash->iterations();
116 }
117 if(param2) {
118 *param2 = pwdhash->parallelism();
119 }
120 if(param3) {
121 *param3 = pwdhash->memory_param();
122 }
123
124 pwdhash->derive_key(out, out_len, password, password_len, salt, salt_len);
125
126 return BOTAN_FFI_SUCCESS;
127 });
128}

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
rngrng object
entropythe data to add
entropy_lenlength of entropy buffer
Returns
0 on success, a negative value on failure

Definition at line 162 of file ffi_rng.cpp.

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

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
rngrng object
Returns
0 if success, error if invalid object handle

Definition at line 143 of file ffi_rng.cpp.

143 {
144 return BOTAN_FFI_CHECKED_DELETE(rng);
145}

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
rngrng object
outoutput buffer of size out_len
out_lennumber of requested bytes
Returns
0 on success, negative on failure

Definition at line 147 of file ffi_rng.cpp.

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

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
rngrng object
rng_typetype of the rng, possible values: "system": system RNG "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 26 of file ffi_rng.cpp.

26 {
27 return ffi_guard_thunk(__func__, [=]() -> int {
28 if(rng_out == nullptr) {
29 return BOTAN_FFI_ERROR_NULL_POINTER;
30 }
31
32 const std::string rng_type_s(rng_type ? rng_type : "system");
33
34 std::unique_ptr<Botan::RandomNumberGenerator> rng;
35
36 if(rng_type_s == "system") {
37 rng = std::make_unique<Botan::System_RNG>();
38 } else if(rng_type_s == "user" || rng_type_s == "user-threadsafe") {
39 rng = std::make_unique<Botan::AutoSeeded_RNG>();
40 } else if(rng_type_s == "null") {
41 rng = std::make_unique<Botan::Null_RNG>();
42 }
43#if defined(BOTAN_HAS_PROCESSOR_RNG)
44 else if((rng_type_s == "rdrand" || rng_type_s == "hwrng") && Botan::Processor_RNG::available()) {
45 rng = std::make_unique<Botan::Processor_RNG>();
46 }
47#endif
48
49 if(!rng) {
50 return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
51 }
52
53 *rng_out = new botan_rng_struct(std::move(rng));
54 return BOTAN_FFI_SUCCESS;
55 });
56}
Botan::Processor_RNG::available
static bool available()
Definition processor_rng.cpp:108

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

◆ botan_rng_init_custom()

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

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

Parameters
rng_outrng object to create
rng_namename of the rng
contextAn application-specific context passed to the callback functions
get_cbCallback for getting random bytes from the rng, return 0 for success
add_entropy_cbCallback for adding entropy to the rng, return 0 for success, may be NULL
destroy_cbCallback called when rng is destroyed, may be NULL

Definition at line 58 of file ffi_rng.cpp.

63 {
64 return ffi_guard_thunk(__func__, [=]() -> int {
65 if(rng_out == nullptr) {
66 return BOTAN_FFI_ERROR_NULL_POINTER;
67 }
68
69 if(rng_name == nullptr) {
70 return BOTAN_FFI_ERROR_NULL_POINTER;
71 }
72
73 if(get_cb == nullptr) {
74 return BOTAN_FFI_ERROR_NULL_POINTER;
75 }
76
77 class Custom_RNG : public Botan::RandomNumberGenerator {
78 public:
79 Custom_RNG(std::string_view name,
80 void* context,
81 int (*get_cb)(void* context, uint8_t* out, size_t out_len),
82 int (*add_entropy_cb)(void* context, const uint8_t input[], size_t length),
83 void (*destroy_cb)(void* context)) :
84 m_name(name) {
85 m_context = context;
86 m_get_cb = get_cb;
87 m_add_entropy_cb = add_entropy_cb;
88 m_destroy_cb = destroy_cb;
89 }
90
91 ~Custom_RNG() override {
92 if(m_destroy_cb) {
93 m_destroy_cb(m_context);
94 }
95 }
96
97 Custom_RNG(const Custom_RNG& other) = delete;
98 Custom_RNG(Custom_RNG&& other) = delete;
99 Custom_RNG& operator=(const Custom_RNG& other) = delete;
100 Custom_RNG& operator=(Custom_RNG&& other) = delete;
101
102 protected:
103 void fill_bytes_with_input(std::span<uint8_t> output, std::span<const uint8_t> input) override {
104 if(accepts_input() && !input.empty()) {
105 int rc = m_add_entropy_cb(m_context, input.data(), input.size());
106 if(rc) {
107 throw Botan::Invalid_State("Failed to add entropy via C callback, rc=" + std::to_string(rc));
108 }
109 }
110
111 if(!output.empty()) {
112 int rc = m_get_cb(m_context, output.data(), output.size());
113 if(rc) {
114 throw Botan::Invalid_State("Failed to get random from C callback, rc=" + std::to_string(rc));
115 }
116 }
117 }
118
119 public:
120 bool accepts_input() const override { return m_add_entropy_cb != nullptr; }
121
122 std::string name() const override { return m_name; }
123
124 void clear() override {}
125
126 bool is_seeded() const override { return true; }
127
128 private:
129 std::string m_name;
130 void* m_context;
131 std::function<int(void* context, uint8_t* out, size_t out_len)> m_get_cb;
132 std::function<int(void* context, const uint8_t input[], size_t length)> m_add_entropy_cb;
133 std::function<void(void* context)> m_destroy_cb;
134 };
135
136 auto rng = std::make_unique<Custom_RNG>(rng_name, context, get_cb, add_entropy_cb, destroy_cb);
137
138 *rng_out = new botan_rng_struct(std::move(rng));
139 return BOTAN_FFI_SUCCESS;
140 });
141}
Botan::Invalid_State
Definition exceptn.h:206

References BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_SUCCESS, Botan_FFI::ffi_guard_thunk(), and name.

◆ 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
rngrng object
bitsnumber of bits to reseed with
Returns
0 on success, a negative value on failure

Definition at line 158 of file ffi_rng.cpp.

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

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
rngrng object
source_rngthe rng that will be read from
bitsnumber of bits to reseed with
Returns
0 on success, a negative value on failure

Definition at line 166 of file ffi_rng.cpp.

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

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

304 {
305 return botan_constant_time_compare(x, y, len);
306}
botan_constant_time_compare
int botan_constant_time_compare(const uint8_t *x, const uint8_t *y, size_t len)
Definition ffi.cpp:298

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

308 {
309 Botan::secure_scrub_memory(mem, bytes);
310 return BOTAN_FFI_SUCCESS;
311}
Botan::secure_scrub_memory
void secure_scrub_memory(void *ptr, size_t n)
Definition os_utils.cpp:87

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.

153 {
154 return botan_pwdhash("Scrypt", N, r, p, out, out_len, password, 0, salt, salt_len);
155}

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
usernamethe username we are attempting login for
passwordthe password we are attempting to use
group_idspecifies the shared SRP group
hash_idspecifies a secure hash function
saltis the salt value sent by the server
salt_lenthe length of salt
Bis the server's public value
B_lenis the server's public value length
rng_objis a random number generator object
Aout buffer to store the SRP-6 A value
A_lenSRP-6 A verifier value length
Kout buffer to store the symmetric value
K_lensymmetric key length
Returns
0 on success, negative on failure

Definition at line 143 of file ffi_srp6.cpp.

155 {
156#if defined(BOTAN_HAS_SRP6)
157 return ffi_guard_thunk(__func__, [=]() -> int {
158 if(!identity || !password || !salt || !group_id || !hash_id || !b || !rng_obj) {
159 return BOTAN_FFI_ERROR_NULL_POINTER;
160 }
161 try {
162 std::vector<uint8_t> saltv(salt, salt + salt_len);
163 Botan::RandomNumberGenerator& rng = safe_get(rng_obj);
164 auto b_bn = Botan::BigInt::decode(b, b_len);
165 auto [A_bn, K_sk] = Botan::srp6_client_agree(identity, password, group_id, hash_id, saltv, b_bn, rng);
166 auto ret_a = write_vec_output(A, A_len, Botan::BigInt::encode(A_bn));
167 auto ret_k = write_vec_output(K, K_len, K_sk.bits_of());
168 if(ret_a != BOTAN_FFI_SUCCESS) {
169 return ret_a;
170 }
171 if(ret_k != BOTAN_FFI_SUCCESS) {
172 return ret_k;
173 }
174 return BOTAN_FFI_SUCCESS;
175 } catch(Botan::Lookup_Error&) {
176 return BOTAN_FFI_ERROR_BAD_PARAMETER;
177 }
178 });
179#else
180 BOTAN_UNUSED(identity, password, group_id, hash_id, rng_obj);
181 BOTAN_UNUSED(salt, salt_len, b, b_len, A, A_len, K, K_len);
182 return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
183#endif
184}
Botan::BigInt::decode
static BigInt decode(const uint8_t buf[], size_t length)
Definition bigint.h:773
Botan::BigInt::encode
static std::vector< uint8_t > encode(const BigInt &n)
Definition bigint.h:750
Botan::Lookup_Error
Definition exceptn.h:235
Botan::srp6_client_agree
std::pair< BigInt, SymmetricKey > srp6_client_agree(std::string_view identifier, std::string_view password, std::string_view group_id, std::string_view hash_id, const std::vector< uint8_t > &salt, const BigInt &B, RandomNumberGenerator &rng)
Definition srp6.cpp:65

References BOTAN_FFI_ERROR_BAD_PARAMETER, BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_SUCCESS, BOTAN_UNUSED, Botan::BigInt::decode(), Botan::BigInt::encode(), Botan_FFI::ffi_guard_thunk(), Botan_FFI::safe_get(), Botan::srp6_client_agree(), and Botan_FFI::write_vec_output().

◆ 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
identifiera username or other client identifier
passwordthe secret used to authenticate user
salta randomly chosen value, at least 128 bits long
salt_lenthe length of salt
group_idspecifies the shared SRP group
hash_idspecifies a secure hash function
verifierout buffer to store the SRP-6 verifier value
verifier_lenSRP-6 verifier value length
Returns
0 on success, negative on failure

Definition at line 115 of file ffi_srp6.cpp.

122 {
123#if defined(BOTAN_HAS_SRP6)
124 return ffi_guard_thunk(__func__, [=]() -> int {
125 if(!username || !password || !salt || !group_id || !hash_id) {
126 return BOTAN_FFI_ERROR_NULL_POINTER;
127 }
128 try {
129 std::vector<uint8_t> salt_vec(salt, salt + salt_len);
130 auto verifier_bn = Botan::srp6_generate_verifier(username, password, salt_vec, group_id, hash_id);
131 return write_vec_output(verifier, verifier_len, Botan::BigInt::encode(verifier_bn));
132 } catch(Botan::Lookup_Error&) {
133 return BOTAN_FFI_ERROR_BAD_PARAMETER;
134 }
135 });
136#else
137 BOTAN_UNUSED(username, password, group_id, hash_id);
138 BOTAN_UNUSED(salt, salt_len, verifier, verifier_len);
139 return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
140#endif
141}
Botan::srp6_generate_verifier
BigInt srp6_generate_verifier(std::string_view identifier, std::string_view password, const std::vector< uint8_t > &salt, std::string_view group_id, std::string_view hash_id)
Definition srp6.cpp:128

References BOTAN_FFI_ERROR_BAD_PARAMETER, BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_UNUSED, Botan::BigInt::encode(), Botan_FFI::ffi_guard_thunk(), Botan::srp6_generate_verifier(), and Botan_FFI::write_vec_output().

◆ 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 47 of file ffi_srp6.cpp.

47 {
48#if defined(BOTAN_HAS_SRP6)
49 if(group_id == nullptr || group_p_bytes == nullptr) {
50 return BOTAN_FFI_ERROR_NULL_POINTER;
51 }
52
53 return ffi_guard_thunk(__func__, [=]() -> int {
54 Botan::DL_Group group(group_id);
55 *group_p_bytes = group.p_bytes();
56 return BOTAN_FFI_SUCCESS;
57 });
58#else
59 BOTAN_UNUSED(group_id, group_p_bytes);
60 return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
61#endif
62}

References BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_SUCCESS, BOTAN_UNUSED, Botan_FFI::ffi_guard_thunk(), and Botan::DL_Group::p_bytes().

◆ 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
srp6SRP-6 server session object
Returns
0 if success, error if invalid object handle

Definition at line 43 of file ffi_srp6.cpp.

43 {
44 return BOTAN_FFI_CHECKED_DELETE(srp6);
45}

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
srp6SRP-6 server session object

Definition at line 31 of file ffi_srp6.cpp.

31 {
32#if defined(BOTAN_HAS_SRP6)
33 return ffi_guard_thunk(__func__, [=]() -> int {
34 *srp6 = new botan_srp6_server_session_struct(std::make_unique<Botan::SRP6_Server_Session>());
35 return BOTAN_FFI_SUCCESS;
36 });
37#else
38 BOTAN_UNUSED(srp6);
39 return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
40#endif
41}

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

◆ 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
srp6SRP-6 server session object
verifierthe verification value saved from client registration
verifier_lenSRP-6 verifier value length
group_idthe SRP group id
hash_idthe SRP hash in use
rng_obja random number generator object
B_pubout buffer to store the SRP-6 B value
B_pub_lenSRP-6 B value length
Returns
0 on success, negative on failure

◆ 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
srp6SRP-6 server session object
Athe client's value
A_lenthe client's value length
keyout buffer to store the symmetric key value
key_lensymmetric key length
Returns
0 on success, negative on failure

Definition at line 94 of file ffi_srp6.cpp.

95 {
96#if defined(BOTAN_HAS_SRP6)
97 return BOTAN_FFI_VISIT(srp6, [=](auto& s) -> int {
98 if(!a) {
99 return BOTAN_FFI_ERROR_NULL_POINTER;
100 }
101 try {
102 Botan::BigInt a_bn = Botan::BigInt::decode(a, a_len);
103 auto key_sk = s.step2(a_bn);
104 return write_vec_output(key, key_len, key_sk.bits_of());
105 } catch(Botan::Decoding_Error&) {
106 return BOTAN_FFI_ERROR_BAD_PARAMETER;
107 }
108 });
109#else
110 BOTAN_UNUSED(srp6, a, a_len, key, key_len);
111 return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
112#endif
113}
Botan::Decoding_Error
Definition exceptn.h:191

References BOTAN_FFI_ERROR_BAD_PARAMETER, BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_VISIT, BOTAN_UNUSED, Botan::BigInt::decode(), and Botan_FFI::write_vec_output().

◆ 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
outoutput buffer of size out_len
out_lennumber of requested bytes
Returns
0 on success, negative on failure

Definition at line 151 of file ffi_rng.cpp.

151 {
152 return ffi_guard_thunk(__func__, [=]() -> int {
153 Botan::system_rng().randomize(out, out_len);
154 return BOTAN_FFI_SUCCESS;
155 });
156}
Botan::RandomNumberGenerator::randomize
void randomize(std::span< uint8_t > output)
Definition rng.h:52

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
totpthe TOTP object
totp_codethe presented OTP
timestampthe current local timestamp
acceptable_clock_driftspecifies the acceptable amount of clock drift (in terms of time steps) between the two hosts.

Definition at line 69 of file ffi_totp.cpp.

69 {
70#if defined(BOTAN_HAS_TOTP)
71 return BOTAN_FFI_VISIT(totp, [=](auto& t) {
72 const bool ok = t.verify_totp(totp_code, timestamp, acceptable_clock_drift);
73 return (ok ? BOTAN_FFI_SUCCESS : BOTAN_FFI_INVALID_VERIFIER);
74 });
75
76#else
77 BOTAN_UNUSED(totp, totp_code, timestamp, acceptable_clock_drift);
78 return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
79#endif
80}

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 46 of file ffi_totp.cpp.

46 {
47#if defined(BOTAN_HAS_TOTP)
48 return BOTAN_FFI_CHECKED_DELETE(totp);
49#else
50 BOTAN_UNUSED(totp);
51 return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
52#endif
53}

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
totpthe TOTP object
totp_codethe OTP code will be written here
timestampthe current local timestamp

Definition at line 55 of file ffi_totp.cpp.

55 {
56#if defined(BOTAN_HAS_TOTP)
57 if(totp == nullptr || totp_code == nullptr) {
58 return BOTAN_FFI_ERROR_NULL_POINTER;
59 }
60
61 return BOTAN_FFI_VISIT(totp, [=](auto& t) { *totp_code = t.generate_totp(timestamp); });
62
63#else
64 BOTAN_UNUSED(totp, totp_code, timestamp);
65 return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
66#endif
67}

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 25 of file ffi_totp.cpp.

26 {
27 if(totp == nullptr || key == nullptr || hash_algo == nullptr) {
28 return BOTAN_FFI_ERROR_NULL_POINTER;
29 }
30
31 *totp = nullptr;
32
33#if defined(BOTAN_HAS_TOTP)
34 return ffi_guard_thunk(__func__, [=]() -> int {
35 auto otp = std::make_unique<Botan::TOTP>(key, key_len, hash_algo, digits, time_step);
36 *totp = new botan_totp_struct(std::move(otp));
37
38 return BOTAN_FFI_SUCCESS;
39 });
40#else
41 BOTAN_UNUSED(totp, key, key_len, hash_algo, digits, time_step);
42 return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
43#endif
44}

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

◆ botan_version_datestamp()

uint32_t botan_version_datestamp ( void )

Return the date this version was released as an integer, or 0 if an unreleased version

Definition at line 294 of file ffi.cpp.

294 {
295 return Botan::version_datestamp();
296}
Botan::version_datestamp
uint32_t version_datestamp()
Definition version.cpp:75

References Botan::version_datestamp().

◆ botan_version_major()

uint32_t botan_version_major ( void )

Return the major version of the library

Definition at line 282 of file ffi.cpp.

282 {
283 return Botan::version_major();
284}
Botan::version_major
uint32_t version_major()
Definition version.cpp:82

References Botan::version_major().

◆ botan_version_minor()

uint32_t botan_version_minor ( void )

Return the minor version of the library

Definition at line 286 of file ffi.cpp.

286 {
287 return Botan::version_minor();
288}
Botan::version_minor
uint32_t version_minor()
Definition version.cpp:86

References Botan::version_minor().

◆ botan_version_patch()

uint32_t botan_version_patch ( void )

Return the patch version of the library

Definition at line 290 of file ffi.cpp.

290 {
291 return Botan::version_patch();
292}
Botan::version_patch
uint32_t version_patch()
Definition version.cpp:90

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

278 {
279 return Botan::version_cstr();
280}
Botan::version_cstr
const char * version_cstr()
Definition version.cpp:33

References Botan::version_cstr().

◆ botan_x509_cert_allowed_usage()

int botan_x509_cert_allowed_usage ( botan_x509_cert_t cert,
unsigned int key_usage )

Definition at line 139 of file ffi_cert.cpp.

139 {
140#if defined(BOTAN_HAS_X509_CERTIFICATES)
141 return BOTAN_FFI_VISIT(cert, [=](const auto& c) -> int {
142 const Botan::Key_Constraints k = static_cast<Botan::Key_Constraints>(key_usage);
143 if(c.allowed_usage(k))
144 return BOTAN_FFI_SUCCESS;
145 return 1;
146 });
147#else
148 BOTAN_UNUSED(cert, key_usage);
149 return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
150#endif
151}
Botan::Key_Constraints
Definition pkix_enums.h:108

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 153 of file ffi_cert.cpp.

153 {
154#if defined(BOTAN_HAS_X509_CERTIFICATES)
155 return BOTAN_FFI_CHECKED_DELETE(cert);
156#else
157 BOTAN_UNUSED(cert);
158 return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
159#endif
160}

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 48 of file ffi_cert.cpp.

48 {
49 if(!cert_obj) {
50 return BOTAN_FFI_ERROR_NULL_POINTER;
51 }
52
53#if defined(BOTAN_HAS_X509_CERTIFICATES) && defined(BOTAN_TARGET_OS_HAS_FILESYSTEM)
54
55 return ffi_guard_thunk(__func__, [=]() -> int {
56 auto c = std::make_unique<Botan::X509_Certificate>(safe_get(cert));
57 *cert_obj = new botan_x509_cert_struct(std::move(c));
58 return BOTAN_FFI_SUCCESS;
59 });
60
61#else
62 BOTAN_UNUSED(cert);
63 return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
64#endif
65}

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

◆ 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 218 of file ffi_cert.cpp.

218 {
219#if defined(BOTAN_HAS_X509_CERTIFICATES)
220 return BOTAN_FFI_VISIT(cert, [=](const auto& c) { return write_vec_output(out, out_len, c.authority_key_id()); });
221#else
222 BOTAN_UNUSED(cert, out, out_len);
223 return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
224#endif
225}

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 209 of file ffi_cert.cpp.

209 {
210#if defined(BOTAN_HAS_X509_CERTIFICATES)
211 return BOTAN_FFI_VISIT(cert, [=](const auto& c) { return write_str_output(out, out_len, c.fingerprint(hash)); });
212#else
213 BOTAN_UNUSED(cert, hash, out, out_len);
214 return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
215#endif
216}

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 )

Definition at line 104 of file ffi_cert.cpp.

105 {
106#if defined(BOTAN_HAS_X509_CERTIFICATES)
107 return BOTAN_FFI_VISIT(cert,
108 [=](const auto& c) { return write_str_output(out, out_len, c.issuer_info(key).at(index)); });
109#else
110 BOTAN_UNUSED(cert, key, index, out, out_len);
111 return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
112#endif
113}

References BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_VISIT, BOTAN_UNUSED, and Botan_FFI::write_str_output().

◆ 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 85 of file ffi_cert.cpp.

85 {
86 if(key == nullptr) {
87 return BOTAN_FFI_ERROR_NULL_POINTER;
88 }
89
90 *key = nullptr;
91
92#if defined(BOTAN_HAS_X509_CERTIFICATES)
93 return ffi_guard_thunk(__func__, [=]() -> int {
94 auto public_key = safe_get(cert).subject_public_key();
95 *key = new botan_pubkey_struct(std::move(public_key));
96 return BOTAN_FFI_SUCCESS;
97 });
98#else
99 BOTAN_UNUSED(cert);
100 return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
101#endif
102}

References BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_SUCCESS, BOTAN_UNUSED, Botan_FFI::ffi_guard_thunk(), 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 236 of file ffi_cert.cpp.

236 {
237 return copy_view_bin(out, out_len, botan_x509_cert_view_public_key_bits, cert);
238}
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 ffi_cert.cpp:240

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 200 of file ffi_cert.cpp.

200 {
201#if defined(BOTAN_HAS_X509_CERTIFICATES)
202 return BOTAN_FFI_VISIT(cert, [=](const auto& c) { return write_vec_output(out, out_len, c.serial_number()); });
203#else
204 BOTAN_UNUSED(cert, out, out_len);
205 return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
206#endif
207}

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 )

Definition at line 115 of file ffi_cert.cpp.

116 {
117#if defined(BOTAN_HAS_X509_CERTIFICATES)
118 return BOTAN_FFI_VISIT(cert,
119 [=](const auto& c) { return write_str_output(out, out_len, c.subject_info(key).at(index)); });
120#else
121 BOTAN_UNUSED(cert, key, index, out, out_len);
122 return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
123#endif
124}

References BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_VISIT, BOTAN_UNUSED, and Botan_FFI::write_str_output().

◆ 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 227 of file ffi_cert.cpp.

227 {
228#if defined(BOTAN_HAS_X509_CERTIFICATES)
229 return BOTAN_FFI_VISIT(cert, [=](const auto& c) { return write_vec_output(out, out_len, c.subject_key_id()); });
230#else
231 BOTAN_UNUSED(cert, out, out_len);
232 return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
233#endif
234}

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 172 of file ffi_cert.cpp.

172 {
173#if defined(BOTAN_HAS_X509_CERTIFICATES)
174 return BOTAN_FFI_VISIT(cert,
175 [=](const auto& c) { return write_str_output(out, out_len, c.not_after().to_string()); });
176#else
177 BOTAN_UNUSED(cert, out, out_len);
178 return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
179#endif
180}

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 162 of file ffi_cert.cpp.

162 {
163#if defined(BOTAN_HAS_X509_CERTIFICATES)
164 return BOTAN_FFI_VISIT(cert,
165 [=](const auto& c) { return write_str_output(out, out_len, c.not_before().to_string()); });
166#else
167 BOTAN_UNUSED(cert, out, out_len);
168 return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
169#endif
170}

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 250 of file ffi_cert.cpp.

250 {
251 if(hostname == nullptr) {
252 return BOTAN_FFI_ERROR_NULL_POINTER;
253 }
254
255#if defined(BOTAN_HAS_X509_CERTIFICATES)
256 return BOTAN_FFI_VISIT(cert, [=](const auto& c) { return c.matches_dns_name(hostname) ? 0 : -1; });
257#else
258 BOTAN_UNUSED(cert);
259 return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
260#endif
261}

References BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_VISIT, and BOTAN_UNUSED.

◆ 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 67 of file ffi_cert.cpp.

67 {
68 if(!cert_obj || !cert_bits) {
69 return BOTAN_FFI_ERROR_NULL_POINTER;
70 }
71
72#if defined(BOTAN_HAS_X509_CERTIFICATES)
73 return ffi_guard_thunk(__func__, [=]() -> int {
74 Botan::DataSource_Memory bits(cert_bits, cert_bits_len);
75 auto c = std::make_unique<Botan::X509_Certificate>(bits);
76 *cert_obj = new botan_x509_cert_struct(std::move(c));
77 return BOTAN_FFI_SUCCESS;
78 });
79#else
80 BOTAN_UNUSED(cert_bits_len);
81 return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
82#endif
83}

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

◆ botan_x509_cert_load_file()

int botan_x509_cert_load_file ( botan_x509_cert_t * cert_obj,
const char * filename )

Definition at line 30 of file ffi_cert.cpp.

30 {
31 if(!cert_obj || !cert_path) {
32 return BOTAN_FFI_ERROR_NULL_POINTER;
33 }
34
35#if defined(BOTAN_HAS_X509_CERTIFICATES) && defined(BOTAN_TARGET_OS_HAS_FILESYSTEM)
36
37 return ffi_guard_thunk(__func__, [=]() -> int {
38 auto c = std::make_unique<Botan::X509_Certificate>(cert_path);
39 *cert_obj = new botan_x509_cert_struct(std::move(c));
40 return BOTAN_FFI_SUCCESS;
41 });
42
43#else
44 return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
45#endif
46}

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

◆ botan_x509_cert_not_after()

int botan_x509_cert_not_after ( botan_x509_cert_t cert,
uint64_t * time_since_epoch )

Definition at line 191 of file ffi_cert.cpp.

191 {
192#if defined(BOTAN_HAS_X509_CERTIFICATES)
193 return BOTAN_FFI_VISIT(cert, [=](const auto& c) { *time_since_epoch = c.not_after().time_since_epoch(); });
194#else
195 BOTAN_UNUSED(cert, time_since_epoch);
196 return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
197#endif
198}

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 182 of file ffi_cert.cpp.

182 {
183#if defined(BOTAN_HAS_X509_CERTIFICATES)
184 return BOTAN_FFI_VISIT(cert, [=](const auto& c) { *time_since_epoch = c.not_before().time_since_epoch(); });
185#else
186 BOTAN_UNUSED(cert, time_since_epoch);
187 return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
188#endif
189}

References BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_VISIT, and BOTAN_UNUSED.

◆ 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 126 of file ffi_cert.cpp.

126 {
127 return copy_view_str(reinterpret_cast<uint8_t*>(out), out_len, botan_x509_cert_view_as_string, cert);
128}
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 ffi_cert.cpp:130

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 330 of file ffi_cert.cpp.

330 {
331 if(code < 0) {
332 return nullptr;
333 }
334
335#if defined(BOTAN_HAS_X509_CERTIFICATES)
336 Botan::Certificate_Status_Code sc = static_cast<Botan::Certificate_Status_Code>(code);
337 return Botan::to_string(sc);
338#else
339 return nullptr;
340#endif
341}
Botan::to_string
std::string to_string(ErrorType type)
Convert an ErrorType to string.
Definition exceptn.cpp:13
Botan::Certificate_Status_Code
Certificate_Status_Code
Definition pkix_enums.h:20

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 263 of file ffi_cert.cpp.

272 {
273 if(required_strength == 0) {
274 required_strength = 110;
275 }
276
277#if defined(BOTAN_HAS_X509_CERTIFICATES)
278 return ffi_guard_thunk(__func__, [=]() -> int {
279 const std::string hostname((hostname_cstr == nullptr) ? "" : hostname_cstr);
280 const Botan::Usage_Type usage = Botan::Usage_Type::UNSPECIFIED;
281 const auto validation_time = reference_time == 0
282 ? std::chrono::system_clock::now()
283 : std::chrono::system_clock::from_time_t(static_cast<time_t>(reference_time));
284
285 std::vector<Botan::X509_Certificate> end_certs;
286 end_certs.push_back(safe_get(cert));
287 for(size_t i = 0; i != intermediates_len; ++i) {
288 end_certs.push_back(safe_get(intermediates[i]));
289 }
290
291 std::unique_ptr<Botan::Certificate_Store> trusted_from_path;
292 std::unique_ptr<Botan::Certificate_Store_In_Memory> trusted_extra;
293 std::vector<Botan::Certificate_Store*> trusted_roots;
294
295 if(trusted_path && *trusted_path) {
296 trusted_from_path = std::make_unique<Botan::Certificate_Store_In_Memory>(trusted_path);
297 trusted_roots.push_back(trusted_from_path.get());
298 }
299
300 if(trusted_len > 0) {
301 trusted_extra = std::make_unique<Botan::Certificate_Store_In_Memory>();
302 for(size_t i = 0; i != trusted_len; ++i) {
303 trusted_extra->add_certificate(safe_get(trusted[i]));
304 }
305 trusted_roots.push_back(trusted_extra.get());
306 }
307
308 Botan::Path_Validation_Restrictions restrictions(false, required_strength);
309
310 auto validation_result =
311 Botan::x509_path_validate(end_certs, restrictions, trusted_roots, hostname, usage, validation_time);
312
313 if(result_code) {
314 *result_code = static_cast<int>(validation_result.result());
315 }
316
317 if(validation_result.successful_validation()) {
318 return 0;
319 } else {
320 return 1;
321 }
322 });
323#else
324 BOTAN_UNUSED(result_code, cert, intermediates, intermediates_len, trusted);
325 BOTAN_UNUSED(trusted_len, trusted_path, hostname_cstr, reference_time);
326 return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
327#endif
328}
Botan::Path_Validation_Restrictions
Definition x509path.h:34
Botan::x509_path_validate
Path_Validation_Result x509_path_validate(const std::vector< X509_Certificate > &end_certs, const Path_Validation_Restrictions &restrictions, const std::vector< Certificate_Store * > &trusted_roots, std::string_view hostname, Usage_Type usage, std::chrono::system_clock::time_point ref_time, std::chrono::milliseconds ocsp_timeout, const std::vector< std::optional< OCSP::Response > > &ocsp_resp)
Definition x509path.cpp:850
Botan::Usage_Type
Usage_Type
Definition x509cert.h:22

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 404 of file ffi_cert.cpp.

415 {
416 if(required_strength == 0) {
417 required_strength = 110;
418 }
419
420#if defined(BOTAN_HAS_X509_CERTIFICATES)
421 return ffi_guard_thunk(__func__, [=]() -> int {
422 const std::string hostname((hostname_cstr == nullptr) ? "" : hostname_cstr);
423 const Botan::Usage_Type usage = Botan::Usage_Type::UNSPECIFIED;
424 const auto validation_time = reference_time == 0
425 ? std::chrono::system_clock::now()
426 : std::chrono::system_clock::from_time_t(static_cast<time_t>(reference_time));
427
428 std::vector<Botan::X509_Certificate> end_certs;
429 end_certs.push_back(safe_get(cert));
430 for(size_t i = 0; i != intermediates_len; ++i) {
431 end_certs.push_back(safe_get(intermediates[i]));
432 }
433
434 std::unique_ptr<Botan::Certificate_Store> trusted_from_path;
435 std::unique_ptr<Botan::Certificate_Store_In_Memory> trusted_extra;
436 std::unique_ptr<Botan::Certificate_Store_In_Memory> trusted_crls;
437 std::vector<Botan::Certificate_Store*> trusted_roots;
438
439 if(trusted_path && *trusted_path) {
440 trusted_from_path = std::make_unique<Botan::Certificate_Store_In_Memory>(trusted_path);
441 trusted_roots.push_back(trusted_from_path.get());
442 }
443
444 if(trusted_len > 0) {
445 trusted_extra = std::make_unique<Botan::Certificate_Store_In_Memory>();
446 for(size_t i = 0; i != trusted_len; ++i) {
447 trusted_extra->add_certificate(safe_get(trusted[i]));
448 }
449 trusted_roots.push_back(trusted_extra.get());
450 }
451
452 if(crls_len > 0) {
453 trusted_crls = std::make_unique<Botan::Certificate_Store_In_Memory>();
454 for(size_t i = 0; i != crls_len; ++i) {
455 trusted_crls->add_crl(safe_get(crls[i]));
456 }
457 trusted_roots.push_back(trusted_crls.get());
458 }
459
460 Botan::Path_Validation_Restrictions restrictions(false, required_strength);
461
462 auto validation_result =
463 Botan::x509_path_validate(end_certs, restrictions, trusted_roots, hostname, usage, validation_time);
464
465 if(result_code) {
466 *result_code = static_cast<int>(validation_result.result());
467 }
468
469 if(validation_result.successful_validation()) {
470 return 0;
471 } else {
472 return 1;
473 }
474 });
475#else
476 BOTAN_UNUSED(result_code, cert, intermediates, intermediates_len, trusted);
477 BOTAN_UNUSED(trusted_len, trusted_path, hostname_cstr, reference_time, crls, crls_len);
478 return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
479#endif
480}

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 130 of file ffi_cert.cpp.

130 {
131#if defined(BOTAN_HAS_X509_CERTIFICATES)
132 return BOTAN_FFI_VISIT(cert, [=](const auto& c) { return invoke_view_callback(view, ctx, c.to_string()); });
133#else
134 BOTAN_UNUSED(cert, ctx, view);
135 return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
136#endif
137}

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_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 240 of file ffi_cert.cpp.

240 {
241#if defined(BOTAN_HAS_X509_CERTIFICATES)
242 return BOTAN_FFI_VISIT(cert,
243 [=](const auto& c) { return invoke_view_callback(view, ctx, c.subject_public_key_bits()); });
244#else
245 BOTAN_UNUSED(cert, ctx, view);
246 return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
247#endif
248}

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_crl_destroy()

int botan_x509_crl_destroy ( botan_x509_crl_t crl)

Definition at line 385 of file ffi_cert.cpp.

385 {
386#if defined(BOTAN_HAS_X509_CERTIFICATES)
387 return BOTAN_FFI_CHECKED_DELETE(crl);
388#else
389 BOTAN_UNUSED(crl);
390 return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
391#endif
392}

References BOTAN_FFI_CHECKED_DELETE, BOTAN_FFI_ERROR_NOT_IMPLEMENTED, and BOTAN_UNUSED.

◆ 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 367 of file ffi_cert.cpp.

367 {
368 if(!crl_obj || !crl_bits) {
369 return BOTAN_FFI_ERROR_NULL_POINTER;
370 }
371
372#if defined(BOTAN_HAS_X509_CERTIFICATES)
373 return ffi_guard_thunk(__func__, [=]() -> int {
374 Botan::DataSource_Memory bits(crl_bits, crl_bits_len);
375 auto c = std::make_unique<Botan::X509_CRL>(bits);
376 *crl_obj = new botan_x509_crl_struct(std::move(c));
377 return BOTAN_FFI_SUCCESS;
378 });
379#else
380 BOTAN_UNUSED(crl_bits_len);
381 return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
382#endif
383}

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

◆ botan_x509_crl_load_file()

int botan_x509_crl_load_file ( botan_x509_crl_t * crl_obj,
const char * crl_path )

Definition at line 349 of file ffi_cert.cpp.

349 {
350 if(!crl_obj || !crl_path) {
351 return BOTAN_FFI_ERROR_NULL_POINTER;
352 }
353
354#if defined(BOTAN_HAS_X509_CERTIFICATES) && defined(BOTAN_TARGET_OS_HAS_FILESYSTEM)
355
356 return ffi_guard_thunk(__func__, [=]() -> int {
357 auto c = std::make_unique<Botan::X509_CRL>(crl_path);
358 *crl_obj = new botan_x509_crl_struct(std::move(c));
359 return BOTAN_FFI_SUCCESS;
360 });
361
362#else
363 return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
364#endif
365}

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

◆ 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 394 of file ffi_cert.cpp.

394 {
395#if defined(BOTAN_HAS_X509_CERTIFICATES)
396 return BOTAN_FFI_VISIT(crl, [=](const auto& c) { return c.is_revoked(safe_get(cert)) ? 0 : -1; });
397#else
398 BOTAN_UNUSED(cert);
399 BOTAN_UNUSED(crl);
400 return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
401#endif
402}

References BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_VISIT, BOTAN_UNUSED, and Botan_FFI::safe_get().

◆ 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
Kthe number of shares needed for recovery
Nthe total number of shares
indexesThe index into the encoder's outputs for the corresponding element of the inputs array. Must be of length K.
inputsK previously encoded shares to decode
shareSizethe length in bytes of each input
outputsAn 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 31 of file ffi_zfec.cpp.

32 {
33#if defined(BOTAN_HAS_ZFEC)
34 return Botan_FFI::ffi_guard_thunk(__func__, [=]() -> int {
35 std::map<size_t, const uint8_t*> shares;
36 for(size_t k = 0; k < K; ++k) {
37 shares.insert(std::pair<size_t, const uint8_t*>(indexes[k], inputs[k]));
38 }
39 Botan::ZFEC(K, N).decode_shares(
40 shares, shareSize, [=](size_t index, const uint8_t block[], size_t blockSize) -> void {
41 std::copy(block, block + blockSize, outputs[index]);
42 });
43 return BOTAN_FFI_SUCCESS;
44 });
45#else
46 BOTAN_UNUSED(K, N, indexes, inputs, shareSize, outputs);
47 return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
48#endif
49}
Botan::ZFEC::decode_shares
void decode_shares(const std::map< size_t, const uint8_t * > &shares, size_t share_size, const output_cb_t &output_cb) const
Definition zfec.cpp:442
blockSize
size_t blockSize
Definition commoncrypto_hash.cpp:26
Botan::AES_AARCH64::K
uint8x16_t K
Definition aes_armv8.cpp:20

References blockSize, BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_SUCCESS, BOTAN_UNUSED, Botan::ZFEC::decode_shares(), and Botan_FFI::ffi_guard_thunk().

◆ 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
Kthe number of shares needed for recovery
Nthe number of shares generated
inputthe data to FEC
sizethe length in bytes of input, which must be a multiple of K
outputsAn 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 17 of file ffi_zfec.cpp.

17 {
18#if defined(BOTAN_HAS_ZFEC)
19 return Botan_FFI::ffi_guard_thunk(__func__, [=]() -> int {
20 Botan::ZFEC(K, N).encode(input, size, [=](size_t index, const uint8_t block[], size_t blockSize) -> void {
21 std::copy(block, block + blockSize, outputs[index]);
22 });
23 return BOTAN_FFI_SUCCESS;
24 });
25#else
26 BOTAN_UNUSED(K, N, input, size, outputs);
27 return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
28#endif
29}
Botan::ZFEC::encode
void encode(const uint8_t input[], size_t size, const output_cb_t &output_cb) const
Definition zfec.cpp:399

References blockSize, BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_SUCCESS, BOTAN_UNUSED, Botan::ZFEC::encode(), and Botan_FFI::ffi_guard_thunk().

Generated by doxygen 1.10.0