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