| /** |
| * \file ctr_drbg.h |
| * |
| * \brief This file contains definitions and functions for the |
| * CTR_DRBG pseudorandom generator. |
| * |
| * CTR_DRBG is a standardized way of building a PRNG from a block-cipher |
| * in counter mode operation, as defined in <em>NIST SP 800-90A: |
| * Recommendation for Random Number Generation Using Deterministic Random |
| * Bit Generators</em>. |
| * |
| * The Mbed TLS implementation of CTR_DRBG uses AES-256 (default) or AES-128 |
| * (if \c MBEDTLS_CTR_DRBG_USE_128_BIT_KEY is enabled at compile time) |
| * as the underlying block cipher, with a derivation function. |
| * |
| * The security strength as defined in NIST SP 800-90A is |
| * 128 bits when AES-128 is used (\c MBEDTLS_CTR_DRBG_USE_128_BIT_KEY enabled) |
| * and 256 bits otherwise, provided that #MBEDTLS_CTR_DRBG_ENTROPY_LEN is |
| * kept at its default value (and not overridden in mbedtls_config.h) and that the |
| * DRBG instance is set up with default parameters. |
| * See the documentation of mbedtls_ctr_drbg_seed() for more |
| * information. |
| */ |
| /* |
| * Copyright The Mbed TLS Contributors |
| * SPDX-License-Identifier: Apache-2.0 |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); you may |
| * not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT |
| * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| #ifndef MBEDTLS_CTR_DRBG_H |
| #define MBEDTLS_CTR_DRBG_H |
| #include "mbedtls/private_access.h" |
| |
| #include "mbedtls/build_info.h" |
| |
| #include "mbedtls/aes.h" |
| |
| #if defined(MBEDTLS_THREADING_C) |
| #include "mbedtls/threading.h" |
| #endif |
| |
| #define MBEDTLS_ERR_CTR_DRBG_ENTROPY_SOURCE_FAILED -0x0034 /**< The entropy source failed. */ |
| #define MBEDTLS_ERR_CTR_DRBG_REQUEST_TOO_BIG -0x0036 /**< The requested random buffer length is too big. */ |
| #define MBEDTLS_ERR_CTR_DRBG_INPUT_TOO_BIG -0x0038 /**< The input (entropy + additional data) is too large. */ |
| #define MBEDTLS_ERR_CTR_DRBG_FILE_IO_ERROR -0x003A /**< Read or write error in file. */ |
| |
| #define MBEDTLS_CTR_DRBG_BLOCKSIZE 16 /**< The block size used by the cipher. */ |
| |
| #if defined(MBEDTLS_CTR_DRBG_USE_128_BIT_KEY) |
| #define MBEDTLS_CTR_DRBG_KEYSIZE 16 |
| /**< The key size in bytes used by the cipher. |
| * |
| * Compile-time choice: 16 bytes (128 bits) |
| * because #MBEDTLS_CTR_DRBG_USE_128_BIT_KEY is enabled. |
| */ |
| #else |
| #define MBEDTLS_CTR_DRBG_KEYSIZE 32 |
| /**< The key size in bytes used by the cipher. |
| * |
| * Compile-time choice: 32 bytes (256 bits) |
| * because \c MBEDTLS_CTR_DRBG_USE_128_BIT_KEY is disabled. |
| */ |
| #endif |
| |
| #define MBEDTLS_CTR_DRBG_KEYBITS ( MBEDTLS_CTR_DRBG_KEYSIZE * 8 ) /**< The key size for the DRBG operation, in bits. */ |
| #define MBEDTLS_CTR_DRBG_SEEDLEN ( MBEDTLS_CTR_DRBG_KEYSIZE + MBEDTLS_CTR_DRBG_BLOCKSIZE ) /**< The seed length, calculated as (counter + AES key). */ |
| |
| /** |
| * \name SECTION: Module settings |
| * |
| * The configuration options you can set for this module are in this section. |
| * Either change them in mbedtls_config.h or define them using the compiler command |
| * line. |
| * \{ |
| */ |
| |
| /** \def MBEDTLS_CTR_DRBG_ENTROPY_LEN |
| * |
| * \brief The amount of entropy used per seed by default, in bytes. |
| */ |
| #if !defined(MBEDTLS_CTR_DRBG_ENTROPY_LEN) |
| #if defined(MBEDTLS_SHA512_C) && !defined(MBEDTLS_ENTROPY_FORCE_SHA256) |
| /** This is 48 bytes because the entropy module uses SHA-512 |
| * (\c MBEDTLS_ENTROPY_FORCE_SHA256 is disabled). |
| */ |
| #define MBEDTLS_CTR_DRBG_ENTROPY_LEN 48 |
| |
| #else /* defined(MBEDTLS_SHA512_C) && !defined(MBEDTLS_ENTROPY_FORCE_SHA256) */ |
| |
| /** This is 32 bytes because the entropy module uses SHA-256 |
| * (the SHA512 module is disabled or |
| * \c MBEDTLS_ENTROPY_FORCE_SHA256 is enabled). |
| */ |
| #if !defined(MBEDTLS_CTR_DRBG_USE_128_BIT_KEY) |
| /** \warning To achieve a 256-bit security strength, you must pass a nonce |
| * to mbedtls_ctr_drbg_seed(). |
| */ |
| #endif /* !defined(MBEDTLS_CTR_DRBG_USE_128_BIT_KEY) */ |
| #define MBEDTLS_CTR_DRBG_ENTROPY_LEN 32 |
| #endif /* defined(MBEDTLS_SHA512_C) && !defined(MBEDTLS_ENTROPY_FORCE_SHA256) */ |
| #endif /* !defined(MBEDTLS_CTR_DRBG_ENTROPY_LEN) */ |
| |
| #if !defined(MBEDTLS_CTR_DRBG_RESEED_INTERVAL) |
| #define MBEDTLS_CTR_DRBG_RESEED_INTERVAL 10000 |
| /**< The interval before reseed is performed by default. */ |
| #endif |
| |
| #if !defined(MBEDTLS_CTR_DRBG_MAX_INPUT) |
| #define MBEDTLS_CTR_DRBG_MAX_INPUT 256 |
| /**< The maximum number of additional input Bytes. */ |
| #endif |
| |
| #if !defined(MBEDTLS_CTR_DRBG_MAX_REQUEST) |
| #define MBEDTLS_CTR_DRBG_MAX_REQUEST 1024 |
| /**< The maximum number of requested Bytes per call. */ |
| #endif |
| |
| #if !defined(MBEDTLS_CTR_DRBG_MAX_SEED_INPUT) |
| #define MBEDTLS_CTR_DRBG_MAX_SEED_INPUT 384 |
| /**< The maximum size of seed or reseed buffer in bytes. */ |
| #endif |
| |
| /* \} name SECTION: Module settings */ |
| |
| #define MBEDTLS_CTR_DRBG_PR_OFF 0 |
| /**< Prediction resistance is disabled. */ |
| #define MBEDTLS_CTR_DRBG_PR_ON 1 |
| /**< Prediction resistance is enabled. */ |
| |
| #ifdef __cplusplus |
| extern "C" { |
| #endif |
| |
| #if MBEDTLS_CTR_DRBG_ENTROPY_LEN >= MBEDTLS_CTR_DRBG_KEYSIZE * 3 / 2 |
| /** The default length of the nonce read from the entropy source. |
| * |
| * This is \c 0 because a single read from the entropy source is sufficient |
| * to include a nonce. |
| * See the documentation of mbedtls_ctr_drbg_seed() for more information. |
| */ |
| #define MBEDTLS_CTR_DRBG_ENTROPY_NONCE_LEN 0 |
| #else |
| /** The default length of the nonce read from the entropy source. |
| * |
| * This is half of the default entropy length because a single read from |
| * the entropy source does not provide enough material to form a nonce. |
| * See the documentation of mbedtls_ctr_drbg_seed() for more information. |
| */ |
| #define MBEDTLS_CTR_DRBG_ENTROPY_NONCE_LEN ( MBEDTLS_CTR_DRBG_ENTROPY_LEN + 1 ) / 2 |
| #endif |
| |
| /** |
| * \brief The CTR_DRBG context structure. |
| */ |
| typedef struct mbedtls_ctr_drbg_context |
| { |
| unsigned char MBEDTLS_PRIVATE(counter)[16]; /*!< The counter (V). */ |
| int MBEDTLS_PRIVATE(reseed_counter); /*!< The reseed counter. |
| * This is the number of requests that have |
| * been made since the last (re)seeding, |
| * minus one. |
| * Before the initial seeding, this field |
| * contains the amount of entropy in bytes |
| * to use as a nonce for the initial seeding, |
| * or -1 if no nonce length has been explicitly |
| * set (see mbedtls_ctr_drbg_set_nonce_len()). |
| */ |
| int MBEDTLS_PRIVATE(prediction_resistance); /*!< This determines whether prediction |
| resistance is enabled, that is |
| whether to systematically reseed before |
| each random generation. */ |
| size_t MBEDTLS_PRIVATE(entropy_len); /*!< The amount of entropy grabbed on each |
| seed or reseed operation, in bytes. */ |
| int MBEDTLS_PRIVATE(reseed_interval); /*!< The reseed interval. |
| * This is the maximum number of requests |
| * that can be made between reseedings. */ |
| |
| mbedtls_aes_context MBEDTLS_PRIVATE(aes_ctx); /*!< The AES context. */ |
| |
| /* |
| * Callbacks (Entropy) |
| */ |
| int (*MBEDTLS_PRIVATE(f_entropy))(void *, unsigned char *, size_t); |
| /*!< The entropy callback function. */ |
| |
| void *MBEDTLS_PRIVATE(p_entropy); /*!< The context for the entropy function. */ |
| |
| #if defined(MBEDTLS_THREADING_C) |
| /* Invariant: the mutex is initialized if and only if f_entropy != NULL. |
| * This means that the mutex is initialized during the initial seeding |
| * in mbedtls_ctr_drbg_seed() and freed in mbedtls_ctr_drbg_free(). |
| * |
| * Note that this invariant may change without notice. Do not rely on it |
| * and do not access the mutex directly in application code. |
| */ |
| mbedtls_threading_mutex_t MBEDTLS_PRIVATE(mutex); |
| #endif |
| } |
| mbedtls_ctr_drbg_context; |
| |
| /** |
| * \brief This function initializes the CTR_DRBG context, |
| * and prepares it for mbedtls_ctr_drbg_seed() |
| * or mbedtls_ctr_drbg_free(). |
| * |
| * \note The reseed interval is |
| * #MBEDTLS_CTR_DRBG_RESEED_INTERVAL by default. |
| * You can override it by calling |
| * mbedtls_ctr_drbg_set_reseed_interval(). |
| * |
| * \param ctx The CTR_DRBG context to initialize. |
| */ |
| void mbedtls_ctr_drbg_init( mbedtls_ctr_drbg_context *ctx ); |
| |
| /** |
| * \brief This function seeds and sets up the CTR_DRBG |
| * entropy source for future reseeds. |
| * |
| * A typical choice for the \p f_entropy and \p p_entropy parameters is |
| * to use the entropy module: |
| * - \p f_entropy is mbedtls_entropy_func(); |
| * - \p p_entropy is an instance of ::mbedtls_entropy_context initialized |
| * with mbedtls_entropy_init() (which registers the platform's default |
| * entropy sources). |
| * |
| * The entropy length is #MBEDTLS_CTR_DRBG_ENTROPY_LEN by default. |
| * You can override it by calling mbedtls_ctr_drbg_set_entropy_len(). |
| * |
| * The entropy nonce length is: |
| * - \c 0 if the entropy length is at least 3/2 times the entropy length, |
| * which guarantees that the security strength is the maximum permitted |
| * by the key size and entropy length according to NIST SP 800-90A §10.2.1; |
| * - Half the entropy length otherwise. |
| * You can override it by calling mbedtls_ctr_drbg_set_nonce_len(). |
| * With the default entropy length, the entropy nonce length is |
| * #MBEDTLS_CTR_DRBG_ENTROPY_NONCE_LEN. |
| * |
| * You can provide a nonce and personalization string in addition to the |
| * entropy source, to make this instantiation as unique as possible. |
| * See SP 800-90A §8.6.7 for more details about nonces. |
| * |
| * The _seed_material_ value passed to the derivation function in |
| * the CTR_DRBG Instantiate Process described in NIST SP 800-90A §10.2.1.3.2 |
| * is the concatenation of the following strings: |
| * - A string obtained by calling \p f_entropy function for the entropy |
| * length. |
| */ |
| #if MBEDTLS_CTR_DRBG_ENTROPY_NONCE_LEN == 0 |
| /** |
| * - If mbedtls_ctr_drbg_set_nonce_len() has been called, a string |
| * obtained by calling \p f_entropy function for the specified length. |
| */ |
| #else |
| /** |
| * - A string obtained by calling \p f_entropy function for the entropy nonce |
| * length. If the entropy nonce length is \c 0, this function does not |
| * make a second call to \p f_entropy. |
| */ |
| #endif |
| #if defined(MBEDTLS_THREADING_C) |
| /** |
| * \note When Mbed TLS is built with threading support, |
| * after this function returns successfully, |
| * it is safe to call mbedtls_ctr_drbg_random() |
| * from multiple threads. Other operations, including |
| * reseeding, are not thread-safe. |
| */ |
| #endif /* MBEDTLS_THREADING_C */ |
| /** |
| * - The \p custom string. |
| * |
| * \note To achieve the nominal security strength permitted |
| * by CTR_DRBG, the entropy length must be: |
| * - at least 16 bytes for a 128-bit strength |
| * (maximum achievable strength when using AES-128); |
| * - at least 32 bytes for a 256-bit strength |
| * (maximum achievable strength when using AES-256). |
| * |
| * In addition, if you do not pass a nonce in \p custom, |
| * the sum of the entropy length |
| * and the entropy nonce length must be: |
| * - at least 24 bytes for a 128-bit strength |
| * (maximum achievable strength when using AES-128); |
| * - at least 48 bytes for a 256-bit strength |
| * (maximum achievable strength when using AES-256). |
| * |
| * \param ctx The CTR_DRBG context to seed. |
| * It must have been initialized with |
| * mbedtls_ctr_drbg_init(). |
| * After a successful call to mbedtls_ctr_drbg_seed(), |
| * you may not call mbedtls_ctr_drbg_seed() again on |
| * the same context unless you call |
| * mbedtls_ctr_drbg_free() and mbedtls_ctr_drbg_init() |
| * again first. |
| * After a failed call to mbedtls_ctr_drbg_seed(), |
| * you must call mbedtls_ctr_drbg_free(). |
| * \param f_entropy The entropy callback, taking as arguments the |
| * \p p_entropy context, the buffer to fill, and the |
| * length of the buffer. |
| * \p f_entropy is always called with a buffer size |
| * less than or equal to the entropy length. |
| * \param p_entropy The entropy context to pass to \p f_entropy. |
| * \param custom The personalization string. |
| * This can be \c NULL, in which case the personalization |
| * string is empty regardless of the value of \p len. |
| * \param len The length of the personalization string. |
| * This must be at most |
| * #MBEDTLS_CTR_DRBG_MAX_SEED_INPUT |
| * - #MBEDTLS_CTR_DRBG_ENTROPY_LEN. |
| * |
| * \return \c 0 on success. |
| * \return #MBEDTLS_ERR_CTR_DRBG_ENTROPY_SOURCE_FAILED on failure. |
| */ |
| int mbedtls_ctr_drbg_seed( mbedtls_ctr_drbg_context *ctx, |
| int (*f_entropy)(void *, unsigned char *, size_t), |
| void *p_entropy, |
| const unsigned char *custom, |
| size_t len ); |
| |
| /** |
| * \brief This function resets CTR_DRBG context to the state immediately |
| * after initial call of mbedtls_ctr_drbg_init(). |
| * |
| * \param ctx The CTR_DRBG context to clear. |
| */ |
| void mbedtls_ctr_drbg_free( mbedtls_ctr_drbg_context *ctx ); |
| |
| /** |
| * \brief This function turns prediction resistance on or off. |
| * The default value is off. |
| * |
| * \note If enabled, entropy is gathered at the beginning of |
| * every call to mbedtls_ctr_drbg_random_with_add() |
| * or mbedtls_ctr_drbg_random(). |
| * Only use this if your entropy source has sufficient |
| * throughput. |
| * |
| * \param ctx The CTR_DRBG context. |
| * \param resistance #MBEDTLS_CTR_DRBG_PR_ON or #MBEDTLS_CTR_DRBG_PR_OFF. |
| */ |
| void mbedtls_ctr_drbg_set_prediction_resistance( mbedtls_ctr_drbg_context *ctx, |
| int resistance ); |
| |
| /** |
| * \brief This function sets the amount of entropy grabbed on each |
| * seed or reseed. |
| * |
| * The default value is #MBEDTLS_CTR_DRBG_ENTROPY_LEN. |
| * |
| * \note The security strength of CTR_DRBG is bounded by the |
| * entropy length. Thus: |
| * - When using AES-256 |
| * (\c MBEDTLS_CTR_DRBG_USE_128_BIT_KEY is disabled, |
| * which is the default), |
| * \p len must be at least 32 (in bytes) |
| * to achieve a 256-bit strength. |
| * - When using AES-128 |
| * (\c MBEDTLS_CTR_DRBG_USE_128_BIT_KEY is enabled) |
| * \p len must be at least 16 (in bytes) |
| * to achieve a 128-bit strength. |
| * |
| * \param ctx The CTR_DRBG context. |
| * \param len The amount of entropy to grab, in bytes. |
| * This must be at most #MBEDTLS_CTR_DRBG_MAX_SEED_INPUT |
| * and at most the maximum length accepted by the |
| * entropy function that is set in the context. |
| */ |
| void mbedtls_ctr_drbg_set_entropy_len( mbedtls_ctr_drbg_context *ctx, |
| size_t len ); |
| |
| /** |
| * \brief This function sets the amount of entropy grabbed |
| * as a nonce for the initial seeding. |
| * |
| * Call this function before calling mbedtls_ctr_drbg_seed() to read |
| * a nonce from the entropy source during the initial seeding. |
| * |
| * \param ctx The CTR_DRBG context. |
| * \param len The amount of entropy to grab for the nonce, in bytes. |
| * This must be at most #MBEDTLS_CTR_DRBG_MAX_SEED_INPUT |
| * and at most the maximum length accepted by the |
| * entropy function that is set in the context. |
| * |
| * \return \c 0 on success. |
| * \return #MBEDTLS_ERR_CTR_DRBG_INPUT_TOO_BIG if \p len is |
| * more than #MBEDTLS_CTR_DRBG_MAX_SEED_INPUT. |
| * \return #MBEDTLS_ERR_CTR_DRBG_ENTROPY_SOURCE_FAILED |
| * if the initial seeding has already taken place. |
| */ |
| int mbedtls_ctr_drbg_set_nonce_len( mbedtls_ctr_drbg_context *ctx, |
| size_t len ); |
| |
| /** |
| * \brief This function sets the reseed interval. |
| * |
| * The reseed interval is the number of calls to mbedtls_ctr_drbg_random() |
| * or mbedtls_ctr_drbg_random_with_add() after which the entropy function |
| * is called again. |
| * |
| * The default value is #MBEDTLS_CTR_DRBG_RESEED_INTERVAL. |
| * |
| * \param ctx The CTR_DRBG context. |
| * \param interval The reseed interval. |
| */ |
| void mbedtls_ctr_drbg_set_reseed_interval( mbedtls_ctr_drbg_context *ctx, |
| int interval ); |
| |
| /** |
| * \brief This function reseeds the CTR_DRBG context, that is |
| * extracts data from the entropy source. |
| * |
| * \note This function is not thread-safe. It is not safe |
| * to call this function if another thread might be |
| * concurrently obtaining random numbers from the same |
| * context or updating or reseeding the same context. |
| * |
| * \param ctx The CTR_DRBG context. |
| * \param additional Additional data to add to the state. Can be \c NULL. |
| * \param len The length of the additional data. |
| * This must be less than |
| * #MBEDTLS_CTR_DRBG_MAX_SEED_INPUT - \c entropy_len |
| * where \c entropy_len is the entropy length |
| * configured for the context. |
| * |
| * \return \c 0 on success. |
| * \return #MBEDTLS_ERR_CTR_DRBG_ENTROPY_SOURCE_FAILED on failure. |
| */ |
| int mbedtls_ctr_drbg_reseed( mbedtls_ctr_drbg_context *ctx, |
| const unsigned char *additional, size_t len ); |
| |
| /** |
| * \brief This function updates the state of the CTR_DRBG context. |
| * |
| * \note This function is not thread-safe. It is not safe |
| * to call this function if another thread might be |
| * concurrently obtaining random numbers from the same |
| * context or updating or reseeding the same context. |
| * |
| * \param ctx The CTR_DRBG context. |
| * \param additional The data to update the state with. This must not be |
| * \c NULL unless \p add_len is \c 0. |
| * \param add_len Length of \p additional in bytes. This must be at |
| * most #MBEDTLS_CTR_DRBG_MAX_SEED_INPUT. |
| * |
| * \return \c 0 on success. |
| * \return #MBEDTLS_ERR_CTR_DRBG_INPUT_TOO_BIG if |
| * \p add_len is more than |
| * #MBEDTLS_CTR_DRBG_MAX_SEED_INPUT. |
| * \return An error from the underlying AES cipher on failure. |
| */ |
| int mbedtls_ctr_drbg_update( mbedtls_ctr_drbg_context *ctx, |
| const unsigned char *additional, |
| size_t add_len ); |
| |
| /** |
| * \brief This function updates a CTR_DRBG instance with additional |
| * data and uses it to generate random data. |
| * |
| * This function automatically reseeds if the reseed counter is exceeded |
| * or prediction resistance is enabled. |
| * |
| * \note This function is not thread-safe. It is not safe |
| * to call this function if another thread might be |
| * concurrently obtaining random numbers from the same |
| * context or updating or reseeding the same context. |
| * |
| * \param p_rng The CTR_DRBG context. This must be a pointer to a |
| * #mbedtls_ctr_drbg_context structure. |
| * \param output The buffer to fill. |
| * \param output_len The length of the buffer in bytes. |
| * \param additional Additional data to update. Can be \c NULL, in which |
| * case the additional data is empty regardless of |
| * the value of \p add_len. |
| * \param add_len The length of the additional data |
| * if \p additional is not \c NULL. |
| * This must be less than #MBEDTLS_CTR_DRBG_MAX_INPUT |
| * and less than |
| * #MBEDTLS_CTR_DRBG_MAX_SEED_INPUT - \c entropy_len |
| * where \c entropy_len is the entropy length |
| * configured for the context. |
| * |
| * \return \c 0 on success. |
| * \return #MBEDTLS_ERR_CTR_DRBG_ENTROPY_SOURCE_FAILED or |
| * #MBEDTLS_ERR_CTR_DRBG_REQUEST_TOO_BIG on failure. |
| */ |
| int mbedtls_ctr_drbg_random_with_add( void *p_rng, |
| unsigned char *output, size_t output_len, |
| const unsigned char *additional, size_t add_len ); |
| |
| /** |
| * \brief This function uses CTR_DRBG to generate random data. |
| * |
| * This function automatically reseeds if the reseed counter is exceeded |
| * or prediction resistance is enabled. |
| */ |
| #if defined(MBEDTLS_THREADING_C) |
| /** |
| * \note When Mbed TLS is built with threading support, |
| * it is safe to call mbedtls_ctr_drbg_random() |
| * from multiple threads. Other operations, including |
| * reseeding, are not thread-safe. |
| */ |
| #endif /* MBEDTLS_THREADING_C */ |
| /** |
| * \param p_rng The CTR_DRBG context. This must be a pointer to a |
| * #mbedtls_ctr_drbg_context structure. |
| * \param output The buffer to fill. |
| * \param output_len The length of the buffer in bytes. |
| * |
| * \return \c 0 on success. |
| * \return #MBEDTLS_ERR_CTR_DRBG_ENTROPY_SOURCE_FAILED or |
| * #MBEDTLS_ERR_CTR_DRBG_REQUEST_TOO_BIG on failure. |
| */ |
| int mbedtls_ctr_drbg_random( void *p_rng, |
| unsigned char *output, size_t output_len ); |
| |
| #if defined(MBEDTLS_FS_IO) |
| /** |
| * \brief This function writes a seed file. |
| * |
| * \param ctx The CTR_DRBG context. |
| * \param path The name of the file. |
| * |
| * \return \c 0 on success. |
| * \return #MBEDTLS_ERR_CTR_DRBG_FILE_IO_ERROR on file error. |
| * \return #MBEDTLS_ERR_CTR_DRBG_ENTROPY_SOURCE_FAILED on reseed |
| * failure. |
| */ |
| int mbedtls_ctr_drbg_write_seed_file( mbedtls_ctr_drbg_context *ctx, const char *path ); |
| |
| /** |
| * \brief This function reads and updates a seed file. The seed |
| * is added to this instance. |
| * |
| * \param ctx The CTR_DRBG context. |
| * \param path The name of the file. |
| * |
| * \return \c 0 on success. |
| * \return #MBEDTLS_ERR_CTR_DRBG_FILE_IO_ERROR on file error. |
| * \return #MBEDTLS_ERR_CTR_DRBG_ENTROPY_SOURCE_FAILED on |
| * reseed failure. |
| * \return #MBEDTLS_ERR_CTR_DRBG_INPUT_TOO_BIG if the existing |
| * seed file is too large. |
| */ |
| int mbedtls_ctr_drbg_update_seed_file( mbedtls_ctr_drbg_context *ctx, const char *path ); |
| #endif /* MBEDTLS_FS_IO */ |
| |
| #if defined(MBEDTLS_SELF_TEST) |
| |
| /** |
| * \brief The CTR_DRBG checkup routine. |
| * |
| * \return \c 0 on success. |
| * \return \c 1 on failure. |
| */ |
| int mbedtls_ctr_drbg_self_test( int verbose ); |
| |
| #endif /* MBEDTLS_SELF_TEST */ |
| |
| #ifdef __cplusplus |
| } |
| #endif |
| |
| #endif /* ctr_drbg.h */ |
