/*

* FFI (C89 API)

* (C) 2015,2017 Jack Lloyd

* (C) 2021 René Fischer

*

* Botan is released under the Simplified BSD License (see license.txt)

*/

#ifndef BOTAN_FFI_H_

#define BOTAN_FFI_H_

#ifdef __cplusplus

extern "C" {

#endif

/*

This header exports some of botan's functionality via a C89 interface. This API

is uesd by the Python, OCaml, Rust, Ruby, and Haskell bindings via those languages

respective ctypes/FFI libraries.

The API is intended to be as easy as possible to call from other

languages, which often have easy ways to call C, because C. But some C

code is easier to deal with than others, so to make things easy this

API follows a few simple rules:

- All interactions are via pointers to opaque structs. No need to worry about

structure padding issues and the like.

- All functions return an int error code (except the version calls, which are

assumed to always have something to say).

- Use simple types: size_t for lengths, const char* NULL terminated strings,

uint8_t for binary.

- No ownership of memory transfers across the API boundary. The API will

consume data from const pointers, and will produce output by writing to

buffers provided by (and allocated by) the caller.

- If exporting a value (a string or a blob) the function takes a pointer to the

output array and a read/write pointer to the length. If the length is insufficient, an

error is returned. So passing nullptr/0 allows querying the final value.

Typically there is also a function which allows querying the expected output

length of a function, for example `botan_hash_output_length` allows knowing in

advance the expected size for `botan_hash_final`. Some of these are exact,

while others such as `botan_pk_op_decrypt_output_length` only provide an upper

bound.

The big exception to this currently is the various functions which serialize

public and private keys, where there are currently no function that can

estimate the serialized size. Here view functions are used; see the handbook

for further details.

TODO:

- Doxygen comments for all functions/params

- TLS

*/

#include <stddef.h>

#include <stdint.h>

/**

* The compile time API version. This matches the value of

* botan_ffi_api_version. This can be used for compile-time checking if a

* particular feature is available.

*

* Note this same value is also reflected in BOTAN_HAS_FFI in build.h, however

* that declaration is not visible here since this header is intentionally

* free-standing, depending only on a few C standard library headers.

*/

#define BOTAN_FFI_API_VERSION 20240408

/**

* 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

*/

#if defined(BOTAN_DLL)

#define BOTAN_FFI_EXPORT(maj, min) BOTAN_DLL

#else

#if defined(__has_attribute)

#if __has_attribute(visibility)

#define BOTAN_FFI_EXPORT(maj, min) __attribute__((visibility("default")))

#endif

#elif defined(_MSC_VER) && !defined(BOTAN_IS_BEING_BUILT)

#define BOTAN_FFI_EXPORT(maj, min) __declspec(dllimport)

#else

#define BOTAN_FFI_EXPORT(maj, min)

#endif

#endif

#if !defined(BOTAN_NO_DEPRECATED_WARNINGS)

#if defined(__has_attribute)

#if __has_attribute(deprecated)

#define BOTAN_FFI_DEPRECATED(msg) __attribute__((deprecated(msg)))

#endif

#elif defined(_MSC_VER)

#define BOTAN_FFI_DEPRECATED(msg) __declspec(deprecated(msg))

#endif

#endif

#if !defined(BOTAN_FFI_DEPRECATED)

#define BOTAN_FFI_DEPRECATED(msg) /**/

#endif

/**

* Error codes

*

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

* botan_error_description

*/

enum BOTAN_FFI_ERROR {

};

typedef void* botan_view_ctx;

/**

* Viewer function for binary data

*

* @param view_ctx some application context

* @param data the binary data

* @param len the length of data in bytes

*/

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

/**

* Viewer function for string data

*

* @param view_ctx some application context

* @param str the null terminated string

* @param len the length of string *including* the null terminator

*/

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

/**

* Convert an error code into a string. Returns "Unknown error"

* if the error code is not a known one.

*/

BOTAN_FFI_EXPORT(2, 8) const char* botan_error_description(int err);

/**

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

*/

BOTAN_FFI_EXPORT(3, 0) const char* botan_error_last_exception_message(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.

*/

BOTAN_FFI_EXPORT(2, 0) uint32_t botan_ffi_api_version(void);

/**

* Return 0 (ok) if the version given is one this library supports.

* botan_ffi_supports_api(botan_ffi_api_version()) will always return 0.

*/

BOTAN_FFI_EXPORT(2, 0) int botan_ffi_supports_api(uint32_t api_version);

/**

* Return a free-form version string, e.g., 2.0.0

*/

BOTAN_FFI_EXPORT(2, 0) const char* botan_version_string(void);

/**

* Return the major version of the library

*/

BOTAN_FFI_EXPORT(2, 0) uint32_t botan_version_major(void);

/**

* Return the minor version of the library

*/

BOTAN_FFI_EXPORT(2, 0) uint32_t botan_version_minor(void);

/**

* Return the patch version of the library

*/

BOTAN_FFI_EXPORT(2, 0) uint32_t botan_version_patch(void);

/**

* Return the date this version was released as

* an integer, or 0 if an unreleased version

*/

BOTAN_FFI_EXPORT(2, 0) uint32_t botan_version_datestamp(void);

/**

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

*/

BOTAN_FFI_EXPORT(2, 3) int botan_constant_time_compare(const uint8_t* x, const uint8_t* y, size_t len);

/**

* Deprecated equivalent to botan_constant_time_compare

*/

BOTAN_FFI_DEPRECATED("Use botan_constant_time_compare")

BOTAN_FFI_EXPORT(2, 0) int botan_same_mem(const uint8_t* x, const uint8_t* y, size_t len);

/**

* Clear out memory using a system specific approach to bypass elision by the

* compiler (currently using RtlSecureZeroMemory or tricks with volatile pointers).

*/

BOTAN_FFI_EXPORT(2, 2) int botan_scrub_mem(void* mem, size_t bytes);

#define BOTAN_FFI_HEX_LOWER_CASE 1

/**

* Perform hex encoding

* @param x is some binary data

* @param len length of x in bytes

* @param out an array of at least x*2 bytes

* @param flags flags out be upper or lower case?

* @return 0 on success, a negative value on failure

*/

BOTAN_FFI_EXPORT(2, 0) int botan_hex_encode(const uint8_t* x, size_t len, char* out, uint32_t flags);

/**

* Perform hex decoding

* @param hex_str a string of hex chars (whitespace is ignored)

* @param in_len the length of hex_str

* @param out the output buffer should be at least strlen(hex_str)/2 bytes

* @param out_len the size of the output buffer on input, set to the number of bytes written

* @return 0 on success, a negative value on failure

*/

BOTAN_FFI_EXPORT(2, 3) int botan_hex_decode(const char* hex_str, size_t in_len, uint8_t* out, size_t* out_len);

/**

* Perform base64 encoding

*/

BOTAN_FFI_EXPORT(2, 3) int botan_base64_encode(const uint8_t* x, size_t len, char* out, size_t* out_len);

/**

* Perform base64 decoding

*/

BOTAN_FFI_EXPORT(2, 3) int botan_base64_decode(const char* base64_str, size_t in_len, uint8_t* out, size_t* out_len);

/**

* RNG type

*/

typedef struct botan_rng_struct* botan_rng_t;

/**

* Initialize a random number generator object

* @param rng rng object

* @param rng_type type 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.

*/

BOTAN_FFI_EXPORT(2, 0) int botan_rng_init(botan_rng_t* rng, const char* rng_type);

/**

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

* @param rng_out rng object to create

* @param rng_name name of the rng

* @param context An application-specific context passed to the callback functions

* @param get_cb Callback for getting random bytes from the rng, return 0 for success

* @param add_entropy_cb Callback for adding entropy to the rng, return 0 for success, may be NULL

* @param destroy_cb Callback called when rng is destroyed, may be NULL

*/

BOTAN_FFI_EXPORT(3, 0)

int botan_rng_init_custom(botan_rng_t* rng_out,

void (*destroy_cb)(void* context));

/**

* Get random bytes from a random number generator

* @param rng rng object

* @param out output buffer of size out_len

* @param out_len number of requested bytes

* @return 0 on success, negative on failure

*/

BOTAN_FFI_EXPORT(2, 0) int botan_rng_get(botan_rng_t rng, uint8_t* out, size_t out_len);

/**

* Get random bytes from system random number generator

* @param out output buffer of size out_len

* @param out_len number of requested bytes

* @return 0 on success, negative on failure

*/

BOTAN_FFI_EXPORT(3, 0) int botan_system_rng_get(uint8_t* out, size_t out_len);

/**

* Reseed a random number generator

* Uses the System_RNG as a seed generator.

*

* @param rng rng object

* @param bits number of bits to reseed with

* @return 0 on success, a negative value on failure

*/

BOTAN_FFI_EXPORT(2, 0) int botan_rng_reseed(botan_rng_t rng, size_t bits);

/**

* Reseed a random number generator

*

* @param rng rng object

* @param source_rng the rng that will be read from

* @param bits number of bits to reseed with

* @return 0 on success, a negative value on failure

*/

BOTAN_FFI_EXPORT(2, 8) int botan_rng_reseed_from_rng(botan_rng_t rng, botan_rng_t source_rng, size_t bits);

/**

* Add some seed material to a random number generator

*

* @param rng rng object

* @param entropy the data to add

* @param entropy_len length of entropy buffer

* @return 0 on success, a negative value on failure

*/

BOTAN_FFI_EXPORT(2, 8) int botan_rng_add_entropy(botan_rng_t rng, const uint8_t* entropy, size_t entropy_len);

/**

* Frees all resources of the random number generator object

* @param rng rng object

* @return 0 if success, error if invalid object handle

*/

BOTAN_FFI_EXPORT(2, 0) int botan_rng_destroy(botan_rng_t rng);

/*

* Hash type

*/

typedef struct botan_hash_struct* botan_hash_t;

/**

* Initialize a hash function object

* @param hash hash object

* @param hash_name name of the hash function, e.g., "SHA-384"

* @param flags should be 0 in current API revision, all other uses are reserved

* and return BOTAN_FFI_ERROR_BAD_FLAG

*/

BOTAN_FFI_EXPORT(2, 0) int botan_hash_init(botan_hash_t* hash, const char* hash_name, uint32_t flags);

/**

* Copy the state of a hash function object

* @param dest destination hash object

* @param source source hash object

* @return 0 on success, a negative value on failure

*/

BOTAN_FFI_EXPORT(2, 2) int botan_hash_copy_state(botan_hash_t* dest, botan_hash_t source);

/**

* Writes the output length of the hash function to *output_length

* @param hash hash object

* @param output_length output buffer to hold the hash function output length

* @return 0 on success, a negative value on failure

*/

BOTAN_FFI_EXPORT(2, 0) int botan_hash_output_length(botan_hash_t hash, size_t* output_length);

/**

* Writes the block size of the hash function to *block_size

* @param hash hash object

* @param block_size output buffer to hold the hash function output length

* @return 0 on success, a negative value on failure

*/

BOTAN_FFI_EXPORT(2, 2) int botan_hash_block_size(botan_hash_t hash, size_t* block_size);

/**

* Send more input to the hash function

* @param hash hash object

* @param in input buffer

* @param in_len number of bytes to read from the input buffer

* @return 0 on success, a negative value on failure

*/

BOTAN_FFI_EXPORT(2, 0) int botan_hash_update(botan_hash_t hash, const uint8_t* in, size_t in_len);

/**

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

* @param hash hash object

* @param out output buffer

* @return 0 on success, a negative value on failure

*/

BOTAN_FFI_EXPORT(2, 0) int botan_hash_final(botan_hash_t hash, uint8_t out[]);

/**

* Reinitializes the state of the hash computation. A hash can

* be computed (with update/final) immediately.

* @param hash hash object

* @return 0 on success, a negative value on failure

*/

BOTAN_FFI_EXPORT(2, 0) int botan_hash_clear(botan_hash_t hash);

/**

* Frees all resources of the hash object

* @param hash hash object

* @return 0 if success, error if invalid object handle

*/

BOTAN_FFI_EXPORT(2, 0) int botan_hash_destroy(botan_hash_t hash);

/**

* Get the name of this hash function

* @param hash the object to read

* @param name output buffer

* @param name_len on input, the length of buffer, on success the number of bytes written

*/

BOTAN_FFI_EXPORT(2, 8) int botan_hash_name(botan_hash_t hash, char* name, size_t* name_len);

/*

* Message Authentication type

*/

typedef struct botan_mac_struct* botan_mac_t;

/**

* Initialize a message authentication code object

* @param mac mac object

* @param mac_name name of the hash function, e.g., "HMAC(SHA-384)"

* @param flags should be 0 in current API revision, all other uses are reserved

* and return a negative value (error code)

* @return 0 on success, a negative value on failure

*/

BOTAN_FFI_EXPORT(2, 0) int botan_mac_init(botan_mac_t* mac, const char* mac_name, uint32_t flags);

/**

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

* @param mac mac object

* @param output_length output buffer to hold the MAC output length

* @return 0 on success, a negative value on failure

*/

BOTAN_FFI_EXPORT(2, 0) int botan_mac_output_length(botan_mac_t mac, size_t* output_length);

/**

* Sets the key on the MAC

* @param mac mac object

* @param key buffer holding the key

* @param key_len size of the key buffer in bytes

* @return 0 on success, a negative value on failure

*/

BOTAN_FFI_EXPORT(2, 0) int botan_mac_set_key(botan_mac_t mac, const uint8_t* key, size_t key_len);

/**

* Sets the nonce on the MAC

* @param mac mac object

* @param nonce buffer holding the key

* @param nonce_len size of the key buffer in bytes

* @return 0 on success, a negative value on failure

*/

BOTAN_FFI_EXPORT(3, 0) int botan_mac_set_nonce(botan_mac_t mac, const uint8_t* nonce, size_t nonce_len);

/**

* Send more input to the message authentication code

* @param mac mac object

* @param buf input buffer

* @param len number of bytes to read from the input buffer

* @return 0 on success, a negative value on failure

*/

BOTAN_FFI_EXPORT(2, 0) int botan_mac_update(botan_mac_t mac, const uint8_t* buf, size_t len);

/**

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

* @param mac mac object

* @param out output buffer

* @return 0 on success, a negative value on failure

*/

BOTAN_FFI_EXPORT(2, 0) int botan_mac_final(botan_mac_t mac, uint8_t out[]);

/**

* Reinitializes the state of the MAC computation. A MAC can

* be computed (with update/final) immediately.

* @param mac mac object

* @return 0 on success, a negative value on failure

*/

BOTAN_FFI_EXPORT(2, 0) int botan_mac_clear(botan_mac_t mac);

/**

* Get the name of this MAC

* @param mac the object to read

* @param name output buffer

* @param name_len on input, the length of buffer, on success the number of bytes written

*/

BOTAN_FFI_EXPORT(2, 8) int botan_mac_name(botan_mac_t mac, char* name, size_t* name_len);

/**

* Get the key length limits of this auth code

* @param mac the object to read

* @param out_minimum_keylength if non-NULL, will be set to minimum keylength of MAC

* @param out_maximum_keylength if non-NULL, will be set to maximum keylength of MAC

* @param out_keylength_modulo if non-NULL will be set to byte multiple of valid keys

*/

BOTAN_FFI_EXPORT(2, 8)

int botan_mac_get_keyspec(botan_mac_t mac,

size_t* out_minimum_keylength,

size_t* out_maximum_keylength,

size_t* out_keylength_modulo);

/**

* Frees all resources of the MAC object

* @param mac mac object

* @return 0 if success, error if invalid object handle

*/

BOTAN_FFI_EXPORT(2, 0) int botan_mac_destroy(botan_mac_t mac);

/*

* Cipher modes

*/

typedef struct botan_cipher_struct* botan_cipher_t;

#define BOTAN_CIPHER_INIT_FLAG_MASK_DIRECTION 1

#define BOTAN_CIPHER_INIT_FLAG_ENCRYPT 0

#define BOTAN_CIPHER_INIT_FLAG_DECRYPT 1

/**

* Initialize a cipher object

*/

BOTAN_FFI_EXPORT(2, 0) int botan_cipher_init(botan_cipher_t* cipher, const char* name, uint32_t flags);

/**

* Return the name of the cipher object

*/

BOTAN_FFI_EXPORT(2, 8) int botan_cipher_name(botan_cipher_t cipher, char* name, size_t* name_len);

/**

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

*/

BOTAN_FFI_EXPORT(2, 8) int botan_cipher_output_length(botan_cipher_t cipher, size_t in_len, size_t* out_len);

/**

* Return if the specified nonce length is valid for this cipher

*/

BOTAN_FFI_EXPORT(2, 0) int botan_cipher_valid_nonce_length(botan_cipher_t cipher, size_t nl);

/**

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

*/

BOTAN_FFI_EXPORT(2, 0) int botan_cipher_get_tag_length(botan_cipher_t cipher, size_t* tag_size);

/**

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

*/

BOTAN_FFI_EXPORT(3, 3) int botan_cipher_is_authenticated(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.

*/

BOTAN_FFI_EXPORT(3, 4) int botan_cipher_requires_entire_message(botan_cipher_t cipher);

/**

* Get the default nonce length of this cipher

*/

BOTAN_FFI_EXPORT(2, 0) int botan_cipher_get_default_nonce_length(botan_cipher_t cipher, size_t* nl);

/**

* Return the update granularity of the cipher; botan_cipher_update must be

* called with blocks of this size, except for the final.

*/

BOTAN_FFI_EXPORT(2, 0) int botan_cipher_get_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.

*/

BOTAN_FFI_EXPORT(3, 0) int botan_cipher_get_ideal_update_granularity(botan_cipher_t cipher, size_t* ug);

/**

* Get information about the key lengths. Prefer botan_cipher_get_keyspec

*/

BOTAN_FFI_EXPORT(2, 0)

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

/**

* Get information about the supported key lengths.

*/

BOTAN_FFI_EXPORT(2, 8)

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

/**

* Set the key for this cipher object

*/

BOTAN_FFI_EXPORT(2, 0) int botan_cipher_set_key(botan_cipher_t cipher, const uint8_t* key, size_t key_len);

/**

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

*/

BOTAN_FFI_EXPORT(2, 8) int botan_cipher_reset(botan_cipher_t cipher);

/**

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

*/

BOTAN_FFI_EXPORT(2, 0) int botan_cipher_set_associated_data(botan_cipher_t cipher, const uint8_t* ad, size_t ad_len);

/**

* Begin processing a new message using the provided nonce

*/

BOTAN_FFI_EXPORT(2, 0) int botan_cipher_start(botan_cipher_t cipher, const uint8_t* nonce, size_t nonce_len);

#define BOTAN_CIPHER_UPDATE_FLAG_FINAL (1U << 0)

/**

* @brief Encrypt/Decrypt some data and/or finalize the encryption/decryption

*

* This encrypts as many bytes from @p input_bytes into @p output_bytes as

* possible. Unless ``BOTAN_CIPHER_UPDATE_FLAG_FINAL`` is set, this function will

* consume bytes in multiples of botan_cipher_get_update_granularity().

* @p input_consumed and @p output_written will be set accordingly and it is the

* caller's responsibility to adapt their buffers accordingly before calling this

* function again. Note that, unless ``BOTAN_CIPHER_UPDATE_FLAG_FINAL`` is set,

* the cipher will at most generate @p input_size output bytes.

*

* Eventually, the caller must set the ``BOTAN_CIPHER_UPDATE_FLAG_FINAL`` flag to

* indicate that no more input will be provided. This will cause the cipher to

* consume all given input bytes and produce the final output; or return a

* ``BOTAN_FFI_ERROR_INSUFFICIENT_BUFFER_SPACE`` error if the given output buffer

* was too small. In the latter case, @p output_written will be set to the

* required buffer size. Calling again with ``BOTAN_CIPHER_UPDATE_FLAG_FINAL``, a

* big enough buffer and no further input will then produce the final output.

*

* Note that some ciphers require the entire message to be provided before any

* output is produced. @sa botan_cipher_requires_entire_message().

*/

BOTAN_FFI_EXPORT(2, 0)

int botan_cipher_update(botan_cipher_t cipher,

size_t* input_consumed);

/**

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

*/

BOTAN_FFI_EXPORT(2, 0) int botan_cipher_clear(botan_cipher_t hash);

/**

* Destroy the cipher object

* @return 0 if success, error if invalid object handle

*/

BOTAN_FFI_EXPORT(2, 0) int botan_cipher_destroy(botan_cipher_t cipher);

/*

* Derive a key from a passphrase for a number of iterations

* @param pbkdf_algo PBKDF algorithm, e.g., "PBKDF2(SHA-256)"

* @param out buffer to store the derived key, must be of out_len bytes

* @param out_len the desired length of the key to produce

* @param passphrase the password to derive the key from

* @param salt a randomly chosen salt

* @param salt_len length of salt in bytes

* @param iterations the number of iterations to use (use 10K or more)

* @return 0 on success, a negative value on failure

*

* Deprecated: use

* botan_pwdhash(pbkdf_algo, iterations, 0, 0, out, out_len,

* passphrase, 0, salt, salt_len);

*/

BOTAN_FFI_DEPRECATED("Use botan_pwdhash")

BOTAN_FFI_EXPORT(2, 0)

int botan_pbkdf(const char* pbkdf_algo,

size_t iterations);

/**

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

* @param pbkdf_algo PBKDF algorithm, e.g., "PBKDF2(SHA-256)"

* @param out buffer to store the derived key, must be of out_len bytes

* @param out_len the desired length of the key to produce

* @param passphrase the password to derive the key from

* @param salt a randomly chosen salt

* @param salt_len length of salt in bytes

* @param milliseconds_to_run if iterations is zero, then instead the PBKDF is

* run until milliseconds_to_run milliseconds has passed

* @param out_iterations_used set to the number iterations executed

* @return 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);

*/

BOTAN_FFI_EXPORT(2, 0)

int botan_pbkdf_timed(const char* pbkdf_algo,

size_t* out_iterations_used);

/*

* Derive a key from a passphrase

* @param algo PBKDF algorithm, e.g., "PBKDF2(SHA-256)" or "Scrypt"

* @param param1 the first PBKDF algorithm parameter

* @param param2 the second PBKDF algorithm parameter (may be zero if unneeded)

* @param param3 the third PBKDF algorithm parameter (may be zero if unneeded)

* @param out buffer to store the derived key, must be of out_len bytes

* @param out_len the desired length of the key to produce

* @param passphrase the password to derive the key from

* @param passphrase_len if > 0, specifies length of password. If len == 0, then

* strlen will be called on passphrase to compute the length.

* @param salt a randomly chosen salt

* @param salt_len length of salt in bytes

* @return 0 on success, a negative value on failure

*/

int BOTAN_FFI_EXPORT(2, 8) botan_pwdhash(const char* algo,

size_t salt_len);

/*

* Derive a key from a passphrase

* @param pbkdf_algo PBKDF algorithm, e.g., "Scrypt" or "PBKDF2(SHA-256)"

* @param msec the desired runtime in milliseconds

* @param param1 will be set to the first password hash parameter

* @param param2 will be set to the second password hash parameter

* @param param3 will be set to the third password hash parameter

* @param out buffer to store the derived key, must be of out_len bytes

* @param out_len the desired length of the key to produce

* @param passphrase the password to derive the key from

* @param passphrase_len if > 0, specifies length of password. If len == 0, then

* strlen will be called on passphrase to compute the length.

* @param salt a randomly chosen salt

* @param salt_len length of salt in bytes

* @return 0 on success, a negative value on failure

*/

int BOTAN_FFI_EXPORT(2, 8) botan_pwdhash_timed(const char* algo,

size_t salt_len);

/**

* Derive a key using scrypt

* Deprecated; use

* botan_pwdhash("Scrypt", N, r, p, out, out_len, password, 0, salt, salt_len);

*/

BOTAN_FFI_DEPRECATED("Use botan_pwdhash")

BOTAN_FFI_EXPORT(2, 8)

int botan_scrypt(uint8_t out[],

size_t p);

/**

* Derive a key

* @param kdf_algo KDF algorithm, e.g., "SP800-56C"

* @param out buffer holding the derived key, must be of length out_len

* @param out_len the desired output length in bytes

* @param secret the secret input

* @param secret_len size of secret in bytes

* @param salt a diversifier

* @param salt_len size of salt in bytes

* @param label purpose for the derived keying material

* @param label_len size of label in bytes

* @return 0 on success, a negative value on failure

*/

BOTAN_FFI_EXPORT(2, 0)

int botan_kdf(const char* kdf_algo,

size_t label_len);

/*

* Raw Block Cipher (PRP) interface

*/

typedef struct botan_block_cipher_struct* botan_block_cipher_t;

/**

* Initialize a block cipher object

*/

BOTAN_FFI_EXPORT(2, 1) int botan_block_cipher_init(botan_block_cipher_t* bc, const char* cipher_name);

/**

* Destroy a block cipher object

* @return 0 if success, error if invalid object handle

*/

BOTAN_FFI_EXPORT(2, 1) int botan_block_cipher_destroy(botan_block_cipher_t bc);

/**

* Reinitializes the block cipher

* @return 0 on success, a negative value on failure

*/

BOTAN_FFI_EXPORT(2, 1) int botan_block_cipher_clear(botan_block_cipher_t bc);

/**

* Set the key for a block cipher instance

*/

BOTAN_FFI_EXPORT(2, 1) int botan_block_cipher_set_key(botan_block_cipher_t bc, const uint8_t key[], size_t len);

/**

* Return the positive block size of this block cipher, or negative to

* indicate an error

*/

BOTAN_FFI_EXPORT(2, 1) int botan_block_cipher_block_size(botan_block_cipher_t bc);

/**

* Encrypt one or more blocks with the cipher

*/

BOTAN_FFI_EXPORT(2, 1)

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

/**

* Decrypt one or more blocks with the cipher

*/

BOTAN_FFI_EXPORT(2, 1)

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

/**

* Get the name of this block cipher

* @param cipher the object to read

* @param name output buffer

* @param name_len on input, the length of buffer, on success the number of bytes written

*/

BOTAN_FFI_EXPORT(2, 8) int botan_block_cipher_name(botan_block_cipher_t cipher, char* name, size_t* name_len);

/**

* Get the key length limits of this block cipher

* @param cipher the object to read

* @param out_minimum_keylength if non-NULL, will be set to minimum keylength of cipher

* @param out_maximum_keylength if non-NULL, will be set to maximum keylength of cipher

* @param out_keylength_modulo if non-NULL will be set to byte multiple of valid keys

*/

BOTAN_FFI_EXPORT(2, 8)

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);

/*

* Multiple precision integers (MPI)

*/

typedef struct botan_mp_struct* botan_mp_t;

/**

* Initialize an MPI

*/

BOTAN_FFI_EXPORT(2, 1) int botan_mp_init(botan_mp_t* mp);

/**

* Destroy (deallocate) an MPI

* @return 0 if success, error if invalid object handle

*/

BOTAN_FFI_EXPORT(2, 1) int botan_mp_destroy(botan_mp_t mp);

/**

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

*/

BOTAN_FFI_EXPORT(2, 1) int botan_mp_to_hex(botan_mp_t mp, char* out);

/**

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

*/

BOTAN_FFI_EXPORT(2, 1) int botan_mp_to_str(botan_mp_t mp, uint8_t base, char* out, size_t* out_len);

/**

* Set the MPI to zero

*/

BOTAN_FFI_EXPORT(2, 1) int botan_mp_clear(botan_mp_t mp);

/**

* Set the MPI value from an int

*/

BOTAN_FFI_EXPORT(2, 1) int botan_mp_set_from_int(botan_mp_t mp, int initial_value);

/**

* Set the MPI value from another MP object

*/

BOTAN_FFI_EXPORT(2, 1) int botan_mp_set_from_mp(botan_mp_t dest, botan_mp_t source);

/**

* Set the MPI value from a string

*/

BOTAN_FFI_EXPORT(2, 1) int botan_mp_set_from_str(botan_mp_t dest, const char* str);

/**

* Set the MPI value from a string with arbitrary radix.

* For arbitrary being 10 or 16.

*/

BOTAN_FFI_EXPORT(2, 1) int botan_mp_set_from_radix_str(botan_mp_t dest, const char* str, size_t radix);

/**

* Return the number of significant bits in the MPI

*/

BOTAN_FFI_EXPORT(2, 1) int botan_mp_num_bits(botan_mp_t n, size_t* bits);

/**

* Return the number of significant bytes in the MPI

*/

BOTAN_FFI_EXPORT(2, 1) int botan_mp_num_bytes(botan_mp_t n, size_t* bytes);

/*

* Convert the MPI to a big-endian binary string. Writes botan_mp_num_bytes to vec

*/

BOTAN_FFI_EXPORT(2, 1) int botan_mp_to_bin(botan_mp_t mp, uint8_t vec[]);

/*

* Set an MP to the big-endian binary value

*/

BOTAN_FFI_EXPORT(2, 1) int botan_mp_from_bin(botan_mp_t mp, const uint8_t vec[], size_t vec_len);

/*

* Convert the MPI to a uint32_t, if possible. Fails if MPI is negative or too large.

*/

BOTAN_FFI_EXPORT(2, 1) int botan_mp_to_uint32(botan_mp_t mp, uint32_t* val);

/**

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

*/

BOTAN_FFI_EXPORT(2, 1) int botan_mp_is_positive(botan_mp_t mp);

/**

* Return 1 iff mp is less than 0

*/

BOTAN_FFI_EXPORT(2, 1) int botan_mp_is_negative(botan_mp_t mp);

BOTAN_FFI_EXPORT(2, 1) int botan_mp_flip_sign(botan_mp_t mp);

BOTAN_FFI_EXPORT(2, 1) int botan_mp_is_zero(botan_mp_t mp);

BOTAN_FFI_DEPRECATED("Use botan_mp_get_bit(0)") BOTAN_FFI_EXPORT(2, 1) int botan_mp_is_odd(botan_mp_t mp);

BOTAN_FFI_DEPRECATED("Use botan_mp_get_bit(0)") BOTAN_FFI_EXPORT(2, 1) int botan_mp_is_even(botan_mp_t mp);

BOTAN_FFI_EXPORT(2, 8) int botan_mp_add_u32(botan_mp_t result, botan_mp_t x, uint32_t y);

BOTAN_FFI_EXPORT(2, 8) int botan_mp_sub_u32(botan_mp_t result, botan_mp_t x, uint32_t y);

BOTAN_FFI_EXPORT(2, 1) int botan_mp_add(botan_mp_t result, botan_mp_t x, botan_mp_t y);

BOTAN_FFI_EXPORT(2, 1) int botan_mp_sub(botan_mp_t result, botan_mp_t x, botan_mp_t y);

BOTAN_FFI_EXPORT(2, 1) int botan_mp_mul(botan_mp_t result, botan_mp_t x, botan_mp_t y);

BOTAN_FFI_EXPORT(2, 1)