1 /** 2 * \file ctr_drbg.h 3 * 4 * \brief This file contains definitions and functions for the 5 * CTR_DRBG pseudorandom generator. 6 * 7 * CTR_DRBG is a standardized way of building a PRNG from a block-cipher 8 * in counter mode operation, as defined in <em>NIST SP 800-90A: 9 * Recommendation for Random Number Generation Using Deterministic Random 10 * Bit Generators</em>. 11 * 12 * The Mbed TLS implementation of CTR_DRBG uses AES-256 (default) or AES-128 13 * (if \c MBEDTLS_CTR_DRBG_USE_128_BIT_KEY is enabled at compile time) 14 * as the underlying block cipher, with a derivation function. 15 * 16 * The security strength as defined in NIST SP 800-90A is 17 * 128 bits when AES-128 is used (\c MBEDTLS_CTR_DRBG_USE_128_BIT_KEY enabled) 18 * and 256 bits otherwise, provided that #MBEDTLS_CTR_DRBG_ENTROPY_LEN is 19 * kept at its default value (and not overridden in mbedtls_config.h) and that the 20 * DRBG instance is set up with default parameters. 21 * See the documentation of mbedtls_ctr_drbg_seed() for more 22 * information. 23 */ 24 /* 25 * Copyright The Mbed TLS Contributors 26 * SPDX-License-Identifier: Apache-2.0 27 * 28 * Licensed under the Apache License, Version 2.0 (the "License"); you may 29 * not use this file except in compliance with the License. 30 * You may obtain a copy of the License at 31 * 32 * http://www.apache.org/licenses/LICENSE-2.0 33 * 34 * Unless required by applicable law or agreed to in writing, software 35 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT 36 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 37 * See the License for the specific language governing permissions and 38 * limitations under the License. 39 */ 40 41 #ifndef MBEDTLS_CTR_DRBG_H 42 #define MBEDTLS_CTR_DRBG_H 43 #include "mbedtls/private_access.h" 44 45 #include "mbedtls/build_info.h" 46 47 #include "mbedtls/aes.h" 48 49 #if defined(MBEDTLS_THREADING_C) 50 #include "mbedtls/threading.h" 51 #endif 52 53 /** The entropy source failed. */ 54 #define MBEDTLS_ERR_CTR_DRBG_ENTROPY_SOURCE_FAILED -0x0034 55 /** The requested random buffer length is too big. */ 56 #define MBEDTLS_ERR_CTR_DRBG_REQUEST_TOO_BIG -0x0036 57 /** The input (entropy + additional data) is too large. */ 58 #define MBEDTLS_ERR_CTR_DRBG_INPUT_TOO_BIG -0x0038 59 /** Read or write error in file. */ 60 #define MBEDTLS_ERR_CTR_DRBG_FILE_IO_ERROR -0x003A 61 62 #define MBEDTLS_CTR_DRBG_BLOCKSIZE 16 /**< The block size used by the cipher. */ 63 64 #if defined(MBEDTLS_CTR_DRBG_USE_128_BIT_KEY) 65 #define MBEDTLS_CTR_DRBG_KEYSIZE 16 66 /**< The key size in bytes used by the cipher. 67 * 68 * Compile-time choice: 16 bytes (128 bits) 69 * because #MBEDTLS_CTR_DRBG_USE_128_BIT_KEY is enabled. 70 */ 71 #else 72 #define MBEDTLS_CTR_DRBG_KEYSIZE 32 73 /**< The key size in bytes used by the cipher. 74 * 75 * Compile-time choice: 32 bytes (256 bits) 76 * because \c MBEDTLS_CTR_DRBG_USE_128_BIT_KEY is disabled. 77 */ 78 #endif 79 80 #define MBEDTLS_CTR_DRBG_KEYBITS ( MBEDTLS_CTR_DRBG_KEYSIZE * 8 ) /**< The key size for the DRBG operation, in bits. */ 81 #define MBEDTLS_CTR_DRBG_SEEDLEN ( MBEDTLS_CTR_DRBG_KEYSIZE + MBEDTLS_CTR_DRBG_BLOCKSIZE ) /**< The seed length, calculated as (counter + AES key). */ 82 83 /** 84 * \name SECTION: Module settings 85 * 86 * The configuration options you can set for this module are in this section. 87 * Either change them in mbedtls_config.h or define them using the compiler command 88 * line. 89 * \{ 90 */ 91 92 /** \def MBEDTLS_CTR_DRBG_ENTROPY_LEN 93 * 94 * \brief The amount of entropy used per seed by default, in bytes. 95 */ 96 #if !defined(MBEDTLS_CTR_DRBG_ENTROPY_LEN) 97 #if defined(MBEDTLS_SHA512_C) && !defined(MBEDTLS_ENTROPY_FORCE_SHA256) 98 /** This is 48 bytes because the entropy module uses SHA-512 99 * (\c MBEDTLS_ENTROPY_FORCE_SHA256 is disabled). 100 */ 101 #define MBEDTLS_CTR_DRBG_ENTROPY_LEN 48 102 103 #else /* defined(MBEDTLS_SHA512_C) && !defined(MBEDTLS_ENTROPY_FORCE_SHA256) */ 104 105 /** This is 32 bytes because the entropy module uses SHA-256 106 * (the SHA512 module is disabled or 107 * \c MBEDTLS_ENTROPY_FORCE_SHA256 is enabled). 108 */ 109 #if !defined(MBEDTLS_CTR_DRBG_USE_128_BIT_KEY) 110 /** \warning To achieve a 256-bit security strength, you must pass a nonce 111 * to mbedtls_ctr_drbg_seed(). 112 */ 113 #endif /* !defined(MBEDTLS_CTR_DRBG_USE_128_BIT_KEY) */ 114 #define MBEDTLS_CTR_DRBG_ENTROPY_LEN 32 115 #endif /* defined(MBEDTLS_SHA512_C) && !defined(MBEDTLS_ENTROPY_FORCE_SHA256) */ 116 #endif /* !defined(MBEDTLS_CTR_DRBG_ENTROPY_LEN) */ 117 118 #if !defined(MBEDTLS_CTR_DRBG_RESEED_INTERVAL) 119 #define MBEDTLS_CTR_DRBG_RESEED_INTERVAL 10000 120 /**< The interval before reseed is performed by default. */ 121 #endif 122 123 #if !defined(MBEDTLS_CTR_DRBG_MAX_INPUT) 124 #define MBEDTLS_CTR_DRBG_MAX_INPUT 256 125 /**< The maximum number of additional input Bytes. */ 126 #endif 127 128 #if !defined(MBEDTLS_CTR_DRBG_MAX_REQUEST) 129 #define MBEDTLS_CTR_DRBG_MAX_REQUEST 1024 130 /**< The maximum number of requested Bytes per call. */ 131 #endif 132 133 #if !defined(MBEDTLS_CTR_DRBG_MAX_SEED_INPUT) 134 #define MBEDTLS_CTR_DRBG_MAX_SEED_INPUT 384 135 /**< The maximum size of seed or reseed buffer in bytes. */ 136 #endif 137 138 /* \} name SECTION: Module settings */ 139 140 #define MBEDTLS_CTR_DRBG_PR_OFF 0 141 /**< Prediction resistance is disabled. */ 142 #define MBEDTLS_CTR_DRBG_PR_ON 1 143 /**< Prediction resistance is enabled. */ 144 145 #ifdef __cplusplus 146 extern "C" { 147 #endif 148 149 #if MBEDTLS_CTR_DRBG_ENTROPY_LEN >= MBEDTLS_CTR_DRBG_KEYSIZE * 3 / 2 150 /** The default length of the nonce read from the entropy source. 151 * 152 * This is \c 0 because a single read from the entropy source is sufficient 153 * to include a nonce. 154 * See the documentation of mbedtls_ctr_drbg_seed() for more information. 155 */ 156 #define MBEDTLS_CTR_DRBG_ENTROPY_NONCE_LEN 0 157 #else 158 /** The default length of the nonce read from the entropy source. 159 * 160 * This is half of the default entropy length because a single read from 161 * the entropy source does not provide enough material to form a nonce. 162 * See the documentation of mbedtls_ctr_drbg_seed() for more information. 163 */ 164 #define MBEDTLS_CTR_DRBG_ENTROPY_NONCE_LEN ( MBEDTLS_CTR_DRBG_ENTROPY_LEN + 1 ) / 2 165 #endif 166 167 /** 168 * \brief The CTR_DRBG context structure. 169 */ 170 typedef struct mbedtls_ctr_drbg_context 171 { 172 unsigned char MBEDTLS_PRIVATE(counter)[16]; /*!< The counter (V). */ 173 int MBEDTLS_PRIVATE(reseed_counter); /*!< The reseed counter. 174 * This is the number of requests that have 175 * been made since the last (re)seeding, 176 * minus one. 177 * Before the initial seeding, this field 178 * contains the amount of entropy in bytes 179 * to use as a nonce for the initial seeding, 180 * or -1 if no nonce length has been explicitly 181 * set (see mbedtls_ctr_drbg_set_nonce_len()). 182 */ 183 int MBEDTLS_PRIVATE(prediction_resistance); /*!< This determines whether prediction 184 resistance is enabled, that is 185 whether to systematically reseed before 186 each random generation. */ 187 size_t MBEDTLS_PRIVATE(entropy_len); /*!< The amount of entropy grabbed on each 188 seed or reseed operation, in bytes. */ 189 int MBEDTLS_PRIVATE(reseed_interval); /*!< The reseed interval. 190 * This is the maximum number of requests 191 * that can be made between reseedings. */ 192 193 mbedtls_aes_context MBEDTLS_PRIVATE(aes_ctx); /*!< The AES context. */ 194 195 /* 196 * Callbacks (Entropy) 197 */ 198 int (*MBEDTLS_PRIVATE(f_entropy))(void *, unsigned char *, size_t); 199 /*!< The entropy callback function. */ 200 201 void *MBEDTLS_PRIVATE(p_entropy); /*!< The context for the entropy function. */ 202 203 #if defined(MBEDTLS_THREADING_C) 204 /* Invariant: the mutex is initialized if and only if f_entropy != NULL. 205 * This means that the mutex is initialized during the initial seeding 206 * in mbedtls_ctr_drbg_seed() and freed in mbedtls_ctr_drbg_free(). 207 * 208 * Note that this invariant may change without notice. Do not rely on it 209 * and do not access the mutex directly in application code. 210 */ 211 mbedtls_threading_mutex_t MBEDTLS_PRIVATE(mutex); 212 #endif 213 } 214 mbedtls_ctr_drbg_context; 215 216 /** 217 * \brief This function initializes the CTR_DRBG context, 218 * and prepares it for mbedtls_ctr_drbg_seed() 219 * or mbedtls_ctr_drbg_free(). 220 * 221 * \note The reseed interval is 222 * #MBEDTLS_CTR_DRBG_RESEED_INTERVAL by default. 223 * You can override it by calling 224 * mbedtls_ctr_drbg_set_reseed_interval(). 225 * 226 * \param ctx The CTR_DRBG context to initialize. 227 */ 228 void mbedtls_ctr_drbg_init( mbedtls_ctr_drbg_context *ctx ); 229 230 /** 231 * \brief This function seeds and sets up the CTR_DRBG 232 * entropy source for future reseeds. 233 * 234 * A typical choice for the \p f_entropy and \p p_entropy parameters is 235 * to use the entropy module: 236 * - \p f_entropy is mbedtls_entropy_func(); 237 * - \p p_entropy is an instance of ::mbedtls_entropy_context initialized 238 * with mbedtls_entropy_init() (which registers the platform's default 239 * entropy sources). 240 * 241 * The entropy length is #MBEDTLS_CTR_DRBG_ENTROPY_LEN by default. 242 * You can override it by calling mbedtls_ctr_drbg_set_entropy_len(). 243 * 244 * The entropy nonce length is: 245 * - \c 0 if the entropy length is at least 3/2 times the entropy length, 246 * which guarantees that the security strength is the maximum permitted 247 * by the key size and entropy length according to NIST SP 800-90A §10.2.1; 248 * - Half the entropy length otherwise. 249 * You can override it by calling mbedtls_ctr_drbg_set_nonce_len(). 250 * With the default entropy length, the entropy nonce length is 251 * #MBEDTLS_CTR_DRBG_ENTROPY_NONCE_LEN. 252 * 253 * You can provide a nonce and personalization string in addition to the 254 * entropy source, to make this instantiation as unique as possible. 255 * See SP 800-90A §8.6.7 for more details about nonces. 256 * 257 * The _seed_material_ value passed to the derivation function in 258 * the CTR_DRBG Instantiate Process described in NIST SP 800-90A §10.2.1.3.2 259 * is the concatenation of the following strings: 260 * - A string obtained by calling \p f_entropy function for the entropy 261 * length. 262 */ 263 #if MBEDTLS_CTR_DRBG_ENTROPY_NONCE_LEN == 0 264 /** 265 * - If mbedtls_ctr_drbg_set_nonce_len() has been called, a string 266 * obtained by calling \p f_entropy function for the specified length. 267 */ 268 #else 269 /** 270 * - A string obtained by calling \p f_entropy function for the entropy nonce 271 * length. If the entropy nonce length is \c 0, this function does not 272 * make a second call to \p f_entropy. 273 */ 274 #endif 275 #if defined(MBEDTLS_THREADING_C) 276 /** 277 * \note When Mbed TLS is built with threading support, 278 * after this function returns successfully, 279 * it is safe to call mbedtls_ctr_drbg_random() 280 * from multiple threads. Other operations, including 281 * reseeding, are not thread-safe. 282 */ 283 #endif /* MBEDTLS_THREADING_C */ 284 /** 285 * - The \p custom string. 286 * 287 * \note To achieve the nominal security strength permitted 288 * by CTR_DRBG, the entropy length must be: 289 * - at least 16 bytes for a 128-bit strength 290 * (maximum achievable strength when using AES-128); 291 * - at least 32 bytes for a 256-bit strength 292 * (maximum achievable strength when using AES-256). 293 * 294 * In addition, if you do not pass a nonce in \p custom, 295 * the sum of the entropy length 296 * and the entropy nonce length must be: 297 * - at least 24 bytes for a 128-bit strength 298 * (maximum achievable strength when using AES-128); 299 * - at least 48 bytes for a 256-bit strength 300 * (maximum achievable strength when using AES-256). 301 * 302 * \param ctx The CTR_DRBG context to seed. 303 * It must have been initialized with 304 * mbedtls_ctr_drbg_init(). 305 * After a successful call to mbedtls_ctr_drbg_seed(), 306 * you may not call mbedtls_ctr_drbg_seed() again on 307 * the same context unless you call 308 * mbedtls_ctr_drbg_free() and mbedtls_ctr_drbg_init() 309 * again first. 310 * After a failed call to mbedtls_ctr_drbg_seed(), 311 * you must call mbedtls_ctr_drbg_free(). 312 * \param f_entropy The entropy callback, taking as arguments the 313 * \p p_entropy context, the buffer to fill, and the 314 * length of the buffer. 315 * \p f_entropy is always called with a buffer size 316 * less than or equal to the entropy length. 317 * \param p_entropy The entropy context to pass to \p f_entropy. 318 * \param custom The personalization string. 319 * This can be \c NULL, in which case the personalization 320 * string is empty regardless of the value of \p len. 321 * \param len The length of the personalization string. 322 * This must be at most 323 * #MBEDTLS_CTR_DRBG_MAX_SEED_INPUT 324 * - #MBEDTLS_CTR_DRBG_ENTROPY_LEN. 325 * 326 * \return \c 0 on success. 327 * \return #MBEDTLS_ERR_CTR_DRBG_ENTROPY_SOURCE_FAILED on failure. 328 */ 329 int mbedtls_ctr_drbg_seed( mbedtls_ctr_drbg_context *ctx, 330 int (*f_entropy)(void *, unsigned char *, size_t), 331 void *p_entropy, 332 const unsigned char *custom, 333 size_t len ); 334 335 /** 336 * \brief This function resets CTR_DRBG context to the state immediately 337 * after initial call of mbedtls_ctr_drbg_init(). 338 * 339 * \param ctx The CTR_DRBG context to clear. 340 */ 341 void mbedtls_ctr_drbg_free( mbedtls_ctr_drbg_context *ctx ); 342 343 /** 344 * \brief This function turns prediction resistance on or off. 345 * The default value is off. 346 * 347 * \note If enabled, entropy is gathered at the beginning of 348 * every call to mbedtls_ctr_drbg_random_with_add() 349 * or mbedtls_ctr_drbg_random(). 350 * Only use this if your entropy source has sufficient 351 * throughput. 352 * 353 * \param ctx The CTR_DRBG context. 354 * \param resistance #MBEDTLS_CTR_DRBG_PR_ON or #MBEDTLS_CTR_DRBG_PR_OFF. 355 */ 356 void mbedtls_ctr_drbg_set_prediction_resistance( mbedtls_ctr_drbg_context *ctx, 357 int resistance ); 358 359 /** 360 * \brief This function sets the amount of entropy grabbed on each 361 * seed or reseed. 362 * 363 * The default value is #MBEDTLS_CTR_DRBG_ENTROPY_LEN. 364 * 365 * \note The security strength of CTR_DRBG is bounded by the 366 * entropy length. Thus: 367 * - When using AES-256 368 * (\c MBEDTLS_CTR_DRBG_USE_128_BIT_KEY is disabled, 369 * which is the default), 370 * \p len must be at least 32 (in bytes) 371 * to achieve a 256-bit strength. 372 * - When using AES-128 373 * (\c MBEDTLS_CTR_DRBG_USE_128_BIT_KEY is enabled) 374 * \p len must be at least 16 (in bytes) 375 * to achieve a 128-bit strength. 376 * 377 * \param ctx The CTR_DRBG context. 378 * \param len The amount of entropy to grab, in bytes. 379 * This must be at most #MBEDTLS_CTR_DRBG_MAX_SEED_INPUT 380 * and at most the maximum length accepted by the 381 * entropy function that is set in the context. 382 */ 383 void mbedtls_ctr_drbg_set_entropy_len( mbedtls_ctr_drbg_context *ctx, 384 size_t len ); 385 386 /** 387 * \brief This function sets the amount of entropy grabbed 388 * as a nonce for the initial seeding. 389 * 390 * Call this function before calling mbedtls_ctr_drbg_seed() to read 391 * a nonce from the entropy source during the initial seeding. 392 * 393 * \param ctx The CTR_DRBG context. 394 * \param len The amount of entropy to grab for the nonce, in bytes. 395 * This must be at most #MBEDTLS_CTR_DRBG_MAX_SEED_INPUT 396 * and at most the maximum length accepted by the 397 * entropy function that is set in the context. 398 * 399 * \return \c 0 on success. 400 * \return #MBEDTLS_ERR_CTR_DRBG_INPUT_TOO_BIG if \p len is 401 * more than #MBEDTLS_CTR_DRBG_MAX_SEED_INPUT. 402 * \return #MBEDTLS_ERR_CTR_DRBG_ENTROPY_SOURCE_FAILED 403 * if the initial seeding has already taken place. 404 */ 405 int mbedtls_ctr_drbg_set_nonce_len( mbedtls_ctr_drbg_context *ctx, 406 size_t len ); 407 408 /** 409 * \brief This function sets the reseed interval. 410 * 411 * The reseed interval is the number of calls to mbedtls_ctr_drbg_random() 412 * or mbedtls_ctr_drbg_random_with_add() after which the entropy function 413 * is called again. 414 * 415 * The default value is #MBEDTLS_CTR_DRBG_RESEED_INTERVAL. 416 * 417 * \param ctx The CTR_DRBG context. 418 * \param interval The reseed interval. 419 */ 420 void mbedtls_ctr_drbg_set_reseed_interval( mbedtls_ctr_drbg_context *ctx, 421 int interval ); 422 423 /** 424 * \brief This function reseeds the CTR_DRBG context, that is 425 * extracts data from the entropy source. 426 * 427 * \note This function is not thread-safe. It is not safe 428 * to call this function if another thread might be 429 * concurrently obtaining random numbers from the same 430 * context or updating or reseeding the same context. 431 * 432 * \param ctx The CTR_DRBG context. 433 * \param additional Additional data to add to the state. Can be \c NULL. 434 * \param len The length of the additional data. 435 * This must be less than 436 * #MBEDTLS_CTR_DRBG_MAX_SEED_INPUT - \c entropy_len 437 * where \c entropy_len is the entropy length 438 * configured for the context. 439 * 440 * \return \c 0 on success. 441 * \return #MBEDTLS_ERR_CTR_DRBG_ENTROPY_SOURCE_FAILED on failure. 442 */ 443 int mbedtls_ctr_drbg_reseed( mbedtls_ctr_drbg_context *ctx, 444 const unsigned char *additional, size_t len ); 445 446 /** 447 * \brief This function updates the state of the CTR_DRBG context. 448 * 449 * \note This function is not thread-safe. It is not safe 450 * to call this function if another thread might be 451 * concurrently obtaining random numbers from the same 452 * context or updating or reseeding the same context. 453 * 454 * \param ctx The CTR_DRBG context. 455 * \param additional The data to update the state with. This must not be 456 * \c NULL unless \p add_len is \c 0. 457 * \param add_len Length of \p additional in bytes. This must be at 458 * most #MBEDTLS_CTR_DRBG_MAX_SEED_INPUT. 459 * 460 * \return \c 0 on success. 461 * \return #MBEDTLS_ERR_CTR_DRBG_INPUT_TOO_BIG if 462 * \p add_len is more than 463 * #MBEDTLS_CTR_DRBG_MAX_SEED_INPUT. 464 * \return An error from the underlying AES cipher on failure. 465 */ 466 int mbedtls_ctr_drbg_update( mbedtls_ctr_drbg_context *ctx, 467 const unsigned char *additional, 468 size_t add_len ); 469 470 /** 471 * \brief This function updates a CTR_DRBG instance with additional 472 * data and uses it to generate random data. 473 * 474 * This function automatically reseeds if the reseed counter is exceeded 475 * or prediction resistance is enabled. 476 * 477 * \note This function is not thread-safe. It is not safe 478 * to call this function if another thread might be 479 * concurrently obtaining random numbers from the same 480 * context or updating or reseeding the same context. 481 * 482 * \param p_rng The CTR_DRBG context. This must be a pointer to a 483 * #mbedtls_ctr_drbg_context structure. 484 * \param output The buffer to fill. 485 * \param output_len The length of the buffer in bytes. 486 * \param additional Additional data to update. Can be \c NULL, in which 487 * case the additional data is empty regardless of 488 * the value of \p add_len. 489 * \param add_len The length of the additional data 490 * if \p additional is not \c NULL. 491 * This must be less than #MBEDTLS_CTR_DRBG_MAX_INPUT 492 * and less than 493 * #MBEDTLS_CTR_DRBG_MAX_SEED_INPUT - \c entropy_len 494 * where \c entropy_len is the entropy length 495 * configured for the context. 496 * 497 * \return \c 0 on success. 498 * \return #MBEDTLS_ERR_CTR_DRBG_ENTROPY_SOURCE_FAILED or 499 * #MBEDTLS_ERR_CTR_DRBG_REQUEST_TOO_BIG on failure. 500 */ 501 int mbedtls_ctr_drbg_random_with_add( void *p_rng, 502 unsigned char *output, size_t output_len, 503 const unsigned char *additional, size_t add_len ); 504 505 /** 506 * \brief This function uses CTR_DRBG to generate random data. 507 * 508 * This function automatically reseeds if the reseed counter is exceeded 509 * or prediction resistance is enabled. 510 */ 511 #if defined(MBEDTLS_THREADING_C) 512 /** 513 * \note When Mbed TLS is built with threading support, 514 * it is safe to call mbedtls_ctr_drbg_random() 515 * from multiple threads. Other operations, including 516 * reseeding, are not thread-safe. 517 */ 518 #endif /* MBEDTLS_THREADING_C */ 519 /** 520 * \param p_rng The CTR_DRBG context. This must be a pointer to a 521 * #mbedtls_ctr_drbg_context structure. 522 * \param output The buffer to fill. 523 * \param output_len The length of the buffer in bytes. 524 * 525 * \return \c 0 on success. 526 * \return #MBEDTLS_ERR_CTR_DRBG_ENTROPY_SOURCE_FAILED or 527 * #MBEDTLS_ERR_CTR_DRBG_REQUEST_TOO_BIG on failure. 528 */ 529 int mbedtls_ctr_drbg_random( void *p_rng, 530 unsigned char *output, size_t output_len ); 531 532 #if defined(MBEDTLS_FS_IO) 533 /** 534 * \brief This function writes a seed file. 535 * 536 * \param ctx The CTR_DRBG context. 537 * \param path The name of the file. 538 * 539 * \return \c 0 on success. 540 * \return #MBEDTLS_ERR_CTR_DRBG_FILE_IO_ERROR on file error. 541 * \return #MBEDTLS_ERR_CTR_DRBG_ENTROPY_SOURCE_FAILED on reseed 542 * failure. 543 */ 544 int mbedtls_ctr_drbg_write_seed_file( mbedtls_ctr_drbg_context *ctx, const char *path ); 545 546 /** 547 * \brief This function reads and updates a seed file. The seed 548 * is added to this instance. 549 * 550 * \param ctx The CTR_DRBG context. 551 * \param path The name of the file. 552 * 553 * \return \c 0 on success. 554 * \return #MBEDTLS_ERR_CTR_DRBG_FILE_IO_ERROR on file error. 555 * \return #MBEDTLS_ERR_CTR_DRBG_ENTROPY_SOURCE_FAILED on 556 * reseed failure. 557 * \return #MBEDTLS_ERR_CTR_DRBG_INPUT_TOO_BIG if the existing 558 * seed file is too large. 559 */ 560 int mbedtls_ctr_drbg_update_seed_file( mbedtls_ctr_drbg_context *ctx, const char *path ); 561 #endif /* MBEDTLS_FS_IO */ 562 563 #if defined(MBEDTLS_SELF_TEST) 564 565 /** 566 * \brief The CTR_DRBG checkup routine. 567 * 568 * \return \c 0 on success. 569 * \return \c 1 on failure. 570 */ 571 int mbedtls_ctr_drbg_self_test( int verbose ); 572 573 #endif /* MBEDTLS_SELF_TEST */ 574 575 #ifdef __cplusplus 576 } 577 #endif 578 579 #endif /* ctr_drbg.h */ 580