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