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 * The initial seeding grabs #MBEDTLS_CTR_DRBG_ENTROPY_LEN bytes of entropy. 16 * See the documentation of mbedtls_ctr_drbg_seed() for more details. 17 * 18 * Based on NIST SP 800-90A §10.2.1 table 3 and NIST SP 800-57 part 1 table 2, 19 * here are the security strengths achieved in typical configuration: 20 * - 256 bits under the default configuration of the library, with AES-256 21 * and with #MBEDTLS_CTR_DRBG_ENTROPY_LEN set to 48 or more. 22 * - 256 bits if AES-256 is used, #MBEDTLS_CTR_DRBG_ENTROPY_LEN is set 23 * to 32 or more, and the DRBG is initialized with an explicit 24 * nonce in the \c custom parameter to mbedtls_ctr_drbg_seed(). 25 * - 128 bits if AES-256 is used but #MBEDTLS_CTR_DRBG_ENTROPY_LEN is 26 * between 24 and 47 and the DRBG is not initialized with an explicit 27 * nonce (see mbedtls_ctr_drbg_seed()). 28 * - 128 bits if AES-128 is used (\c MBEDTLS_CTR_DRBG_USE_128_BIT_KEY enabled) 29 * and #MBEDTLS_CTR_DRBG_ENTROPY_LEN is set to 24 or more (which is 30 * always the case unless it is explicitly set to a different value 31 * in config.h). 32 * 33 * Note that the value of #MBEDTLS_CTR_DRBG_ENTROPY_LEN defaults to: 34 * - \c 48 if the module \c MBEDTLS_SHA512_C is enabled and the symbol 35 * \c MBEDTLS_ENTROPY_FORCE_SHA256 is disabled at compile time. 36 * This is the default configuration of the library. 37 * - \c 32 if the module \c MBEDTLS_SHA512_C is disabled at compile time. 38 * - \c 32 if \c MBEDTLS_ENTROPY_FORCE_SHA256 is enabled at compile time. 39 */ 40 /* 41 * Copyright The Mbed TLS Contributors 42 * SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later 43 * 44 * This file is provided under the Apache License 2.0, or the 45 * GNU General Public License v2.0 or later. 46 * 47 * ********** 48 * Apache License 2.0: 49 * 50 * Licensed under the Apache License, Version 2.0 (the "License"); you may 51 * not use this file except in compliance with the License. 52 * You may obtain a copy of the License at 53 * 54 * http://www.apache.org/licenses/LICENSE-2.0 55 * 56 * Unless required by applicable law or agreed to in writing, software 57 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT 58 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 59 * See the License for the specific language governing permissions and 60 * limitations under the License. 61 * 62 * ********** 63 * 64 * ********** 65 * GNU General Public License v2.0 or later: 66 * 67 * This program is free software; you can redistribute it and/or modify 68 * it under the terms of the GNU General Public License as published by 69 * the Free Software Foundation; either version 2 of the License, or 70 * (at your option) any later version. 71 * 72 * This program is distributed in the hope that it will be useful, 73 * but WITHOUT ANY WARRANTY; without even the implied warranty of 74 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 75 * GNU General Public License for more details. 76 * 77 * You should have received a copy of the GNU General Public License along 78 * with this program; if not, write to the Free Software Foundation, Inc., 79 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. 80 * 81 * ********** 82 */ 83 84 #ifndef MBEDTLS_CTR_DRBG_H 85 #define MBEDTLS_CTR_DRBG_H 86 87 #if !defined(MBEDTLS_CONFIG_FILE) 88 #include "config.h" 89 #else 90 #include MBEDTLS_CONFIG_FILE 91 #endif 92 93 #include "aes.h" 94 95 #if defined(MBEDTLS_THREADING_C) 96 #include "threading.h" 97 #endif 98 99 #define MBEDTLS_ERR_CTR_DRBG_ENTROPY_SOURCE_FAILED -0x0034 /**< The entropy source failed. */ 100 #define MBEDTLS_ERR_CTR_DRBG_REQUEST_TOO_BIG -0x0036 /**< The requested random buffer length is too big. */ 101 #define MBEDTLS_ERR_CTR_DRBG_INPUT_TOO_BIG -0x0038 /**< The input (entropy + additional data) is too large. */ 102 #define MBEDTLS_ERR_CTR_DRBG_FILE_IO_ERROR -0x003A /**< Read or write error in file. */ 103 104 #define MBEDTLS_CTR_DRBG_BLOCKSIZE 16 /**< The block size used by the cipher. */ 105 106 #if defined(MBEDTLS_CTR_DRBG_USE_128_BIT_KEY) 107 #define MBEDTLS_CTR_DRBG_KEYSIZE 16 108 /**< The key size in bytes used by the cipher. 109 * 110 * Compile-time choice: 16 bytes (128 bits) 111 * because #MBEDTLS_CTR_DRBG_USE_128_BIT_KEY is enabled. 112 */ 113 #else 114 #define MBEDTLS_CTR_DRBG_KEYSIZE 32 115 /**< The key size in bytes used by the cipher. 116 * 117 * Compile-time choice: 32 bytes (256 bits) 118 * because \c MBEDTLS_CTR_DRBG_USE_128_BIT_KEY is disabled. 119 */ 120 #endif 121 122 #define MBEDTLS_CTR_DRBG_KEYBITS ( MBEDTLS_CTR_DRBG_KEYSIZE * 8 ) /**< The key size for the DRBG operation, in bits. */ 123 #define MBEDTLS_CTR_DRBG_SEEDLEN ( MBEDTLS_CTR_DRBG_KEYSIZE + MBEDTLS_CTR_DRBG_BLOCKSIZE ) /**< The seed length, calculated as (counter + AES key). */ 124 125 /** 126 * \name SECTION: Module settings 127 * 128 * The configuration options you can set for this module are in this section. 129 * Either change them in config.h or define them using the compiler command 130 * line. 131 * \{ 132 */ 133 134 /** \def MBEDTLS_CTR_DRBG_ENTROPY_LEN 135 * 136 * \brief The amount of entropy used per seed by default, in bytes. 137 */ 138 #if !defined(MBEDTLS_CTR_DRBG_ENTROPY_LEN) 139 #if defined(MBEDTLS_SHA512_C) && !defined(MBEDTLS_ENTROPY_FORCE_SHA256) 140 /** This is 48 bytes because the entropy module uses SHA-512 141 * (\c MBEDTLS_ENTROPY_FORCE_SHA256 is disabled). 142 */ 143 #define MBEDTLS_CTR_DRBG_ENTROPY_LEN 48 144 145 #else /* defined(MBEDTLS_SHA512_C) && !defined(MBEDTLS_ENTROPY_FORCE_SHA256) */ 146 147 /** This is 32 bytes because the entropy module uses SHA-256 148 * (the SHA512 module is disabled or 149 * \c MBEDTLS_ENTROPY_FORCE_SHA256 is enabled). 150 */ 151 #if !defined(MBEDTLS_CTR_DRBG_USE_128_BIT_KEY) 152 /** \warning To achieve a 256-bit security strength, you must pass a nonce 153 * to mbedtls_ctr_drbg_seed(). 154 */ 155 #endif /* !defined(MBEDTLS_CTR_DRBG_USE_128_BIT_KEY) */ 156 #define MBEDTLS_CTR_DRBG_ENTROPY_LEN 32 157 #endif /* defined(MBEDTLS_SHA512_C) && !defined(MBEDTLS_ENTROPY_FORCE_SHA256) */ 158 #endif /* !defined(MBEDTLS_CTR_DRBG_ENTROPY_LEN) */ 159 160 #if !defined(MBEDTLS_CTR_DRBG_RESEED_INTERVAL) 161 #define MBEDTLS_CTR_DRBG_RESEED_INTERVAL 10000 162 /**< The interval before reseed is performed by default. */ 163 #endif 164 165 #if !defined(MBEDTLS_CTR_DRBG_MAX_INPUT) 166 #define MBEDTLS_CTR_DRBG_MAX_INPUT 256 167 /**< The maximum number of additional input Bytes. */ 168 #endif 169 170 #if !defined(MBEDTLS_CTR_DRBG_MAX_REQUEST) 171 #define MBEDTLS_CTR_DRBG_MAX_REQUEST 1024 172 /**< The maximum number of requested Bytes per call. */ 173 #endif 174 175 #if !defined(MBEDTLS_CTR_DRBG_MAX_SEED_INPUT) 176 #define MBEDTLS_CTR_DRBG_MAX_SEED_INPUT 384 177 /**< The maximum size of seed or reseed buffer in bytes. */ 178 #endif 179 180 /* \} name SECTION: Module settings */ 181 182 #define MBEDTLS_CTR_DRBG_PR_OFF 0 183 /**< Prediction resistance is disabled. */ 184 #define MBEDTLS_CTR_DRBG_PR_ON 1 185 /**< Prediction resistance is enabled. */ 186 187 #ifdef __cplusplus 188 extern "C" { 189 #endif 190 191 /** 192 * \brief The CTR_DRBG context structure. 193 */ 194 typedef struct mbedtls_ctr_drbg_context 195 { 196 unsigned char counter[16]; /*!< The counter (V). */ 197 int reseed_counter; /*!< The reseed counter. */ 198 int prediction_resistance; /*!< This determines whether prediction 199 resistance is enabled, that is 200 whether to systematically reseed before 201 each random generation. */ 202 size_t entropy_len; /*!< The amount of entropy grabbed on each 203 seed or reseed operation. */ 204 int reseed_interval; /*!< The reseed interval. */ 205 206 mbedtls_aes_context aes_ctx; /*!< The AES context. */ 207 208 /* 209 * Callbacks (Entropy) 210 */ 211 int (*f_entropy)(void *, unsigned char *, size_t); 212 /*!< The entropy callback function. */ 213 214 void *p_entropy; /*!< The context for the entropy function. */ 215 216 #if defined(MBEDTLS_THREADING_C) 217 /* Invariant: the mutex is initialized if and only if f_entropy != NULL. 218 * This means that the mutex is initialized during the initial seeding 219 * in mbedtls_ctr_drbg_seed() and freed in mbedtls_ctr_drbg_free(). 220 * 221 * Note that this invariant may change without notice. Do not rely on it 222 * and do not access the mutex directly in application code. 223 */ 224 mbedtls_threading_mutex_t mutex; 225 #endif 226 } 227 mbedtls_ctr_drbg_context; 228 229 /** 230 * \brief This function initializes the CTR_DRBG context, 231 * and prepares it for mbedtls_ctr_drbg_seed() 232 * or mbedtls_ctr_drbg_free(). 233 * 234 * \note The reseed interval is 235 * #MBEDTLS_CTR_DRBG_RESEED_INTERVAL by default. 236 * You can override it by calling 237 * mbedtls_ctr_drbg_set_reseed_interval(). 238 * 239 * \param ctx The CTR_DRBG context to initialize. 240 */ 241 void mbedtls_ctr_drbg_init( mbedtls_ctr_drbg_context *ctx ); 242 243 /** 244 * \brief This function seeds and sets up the CTR_DRBG 245 * entropy source for future reseeds. 246 * 247 * A typical choice for the \p f_entropy and \p p_entropy parameters is 248 * to use the entropy module: 249 * - \p f_entropy is mbedtls_entropy_func(); 250 * - \p p_entropy is an instance of ::mbedtls_entropy_context initialized 251 * with mbedtls_entropy_init() (which registers the platform's default 252 * entropy sources). 253 * 254 * The entropy length is #MBEDTLS_CTR_DRBG_ENTROPY_LEN by default. 255 * You can override it by calling mbedtls_ctr_drbg_set_entropy_len(). 256 * 257 * You can provide a personalization string in addition to the 258 * entropy source, to make this instantiation as unique as possible. 259 * 260 * \note The _seed_material_ value passed to the derivation 261 * function in the CTR_DRBG Instantiate Process 262 * described in NIST SP 800-90A §10.2.1.3.2 263 * is the concatenation of the string obtained from 264 * calling \p f_entropy and the \p custom string. 265 * The origin of the nonce depends on the value of 266 * the entropy length relative to the security strength. 267 * - If the entropy length is at least 1.5 times the 268 * security strength then the nonce is taken from the 269 * string obtained with \p f_entropy. 270 * - If the entropy length is less than the security 271 * strength, then the nonce is taken from \p custom. 272 * In this case, for compliance with SP 800-90A, 273 * you must pass a unique value of \p custom at 274 * each invocation. See SP 800-90A §8.6.7 for more 275 * details. 276 */ 277 #if MBEDTLS_CTR_DRBG_ENTROPY_LEN < MBEDTLS_CTR_DRBG_KEYSIZE * 3 / 2 278 /** \warning When #MBEDTLS_CTR_DRBG_ENTROPY_LEN is less than 279 * #MBEDTLS_CTR_DRBG_KEYSIZE * 3 / 2, to achieve the 280 * maximum security strength permitted by CTR_DRBG, 281 * you must pass a value of \p custom that is a nonce: 282 * this value must never be repeated in subsequent 283 * runs of the same application or on a different 284 * device. 285 */ 286 #endif 287 #if defined(MBEDTLS_THREADING_C) 288 /** 289 * \note When Mbed TLS is built with threading support, 290 * after this function returns successfully, 291 * it is safe to call mbedtls_ctr_drbg_random() 292 * from multiple threads. Other operations, including 293 * reseeding, are not thread-safe. 294 */ 295 #endif /* MBEDTLS_THREADING_C */ 296 /** 297 * \param ctx The CTR_DRBG context to seed. 298 * It must have been initialized with 299 * mbedtls_ctr_drbg_init(). 300 * After a successful call to mbedtls_ctr_drbg_seed(), 301 * you may not call mbedtls_ctr_drbg_seed() again on 302 * the same context unless you call 303 * mbedtls_ctr_drbg_free() and mbedtls_ctr_drbg_init() 304 * again first. 305 * After a failed call to mbedtls_ctr_drbg_seed(), 306 * you must call mbedtls_ctr_drbg_free(). 307 * \param f_entropy The entropy callback, taking as arguments the 308 * \p p_entropy context, the buffer to fill, and the 309 * length of the buffer. 310 * \p f_entropy is always called with a buffer size 311 * equal to the entropy length. 312 * \param p_entropy The entropy context to pass to \p f_entropy. 313 * \param custom The personalization string. 314 * This can be \c NULL, in which case the personalization 315 * string is empty regardless of the value of \p len. 316 * \param len The length of the personalization string. 317 * This must be at most 318 * #MBEDTLS_CTR_DRBG_MAX_SEED_INPUT 319 * - #MBEDTLS_CTR_DRBG_ENTROPY_LEN. 320 * 321 * \return \c 0 on success. 322 * \return #MBEDTLS_ERR_CTR_DRBG_ENTROPY_SOURCE_FAILED on failure. 323 */ 324 int mbedtls_ctr_drbg_seed( mbedtls_ctr_drbg_context *ctx, 325 int (*f_entropy)(void *, unsigned char *, size_t), 326 void *p_entropy, 327 const unsigned char *custom, 328 size_t len ); 329 330 /** 331 * \brief This function resets CTR_DRBG context to the state immediately 332 * after initial call of mbedtls_ctr_drbg_init(). 333 * 334 * \param ctx The CTR_DRBG context to clear. 335 */ 336 void mbedtls_ctr_drbg_free( mbedtls_ctr_drbg_context *ctx ); 337 338 /** 339 * \brief This function turns prediction resistance on or off. 340 * The default value is off. 341 * 342 * \note If enabled, entropy is gathered at the beginning of 343 * every call to mbedtls_ctr_drbg_random_with_add() 344 * or mbedtls_ctr_drbg_random(). 345 * Only use this if your entropy source has sufficient 346 * throughput. 347 * 348 * \param ctx The CTR_DRBG context. 349 * \param resistance #MBEDTLS_CTR_DRBG_PR_ON or #MBEDTLS_CTR_DRBG_PR_OFF. 350 */ 351 void mbedtls_ctr_drbg_set_prediction_resistance( mbedtls_ctr_drbg_context *ctx, 352 int resistance ); 353 354 /** 355 * \brief This function sets the amount of entropy grabbed on each 356 * seed or reseed. 357 * 358 * The default value is #MBEDTLS_CTR_DRBG_ENTROPY_LEN. 359 * 360 * \note The security strength of CTR_DRBG is bounded by the 361 * entropy length. Thus: 362 * - When using AES-256 363 * (\c MBEDTLS_CTR_DRBG_USE_128_BIT_KEY is disabled, 364 * which is the default), 365 * \p len must be at least 32 (in bytes) 366 * to achieve a 256-bit strength. 367 * - When using AES-128 368 * (\c MBEDTLS_CTR_DRBG_USE_128_BIT_KEY is enabled) 369 * \p len must be at least 16 (in bytes) 370 * to achieve a 128-bit strength. 371 * 372 * \param ctx The CTR_DRBG context. 373 * \param len The amount of entropy to grab, in bytes. 374 * This must be at most #MBEDTLS_CTR_DRBG_MAX_SEED_INPUT. 375 */ 376 void mbedtls_ctr_drbg_set_entropy_len( mbedtls_ctr_drbg_context *ctx, 377 size_t len ); 378 379 /** 380 * \brief This function sets the reseed interval. 381 * 382 * The reseed interval is the number of calls to mbedtls_ctr_drbg_random() 383 * or mbedtls_ctr_drbg_random_with_add() after which the entropy function 384 * is called again. 385 * 386 * The default value is #MBEDTLS_CTR_DRBG_RESEED_INTERVAL. 387 * 388 * \param ctx The CTR_DRBG context. 389 * \param interval The reseed interval. 390 */ 391 void mbedtls_ctr_drbg_set_reseed_interval( mbedtls_ctr_drbg_context *ctx, 392 int interval ); 393 394 /** 395 * \brief This function reseeds the CTR_DRBG context, that is 396 * extracts data from the entropy source. 397 * 398 * \note This function is not thread-safe. It is not safe 399 * to call this function if another thread might be 400 * concurrently obtaining random numbers from the same 401 * context or updating or reseeding the same context. 402 * 403 * \param ctx The CTR_DRBG context. 404 * \param additional Additional data to add to the state. Can be \c NULL. 405 * \param len The length of the additional data. 406 * This must be less than 407 * #MBEDTLS_CTR_DRBG_MAX_SEED_INPUT - \c entropy_len 408 * where \c entropy_len is the entropy length 409 * configured for the context. 410 * 411 * \return \c 0 on success. 412 * \return #MBEDTLS_ERR_CTR_DRBG_ENTROPY_SOURCE_FAILED on failure. 413 */ 414 int mbedtls_ctr_drbg_reseed( mbedtls_ctr_drbg_context *ctx, 415 const unsigned char *additional, size_t len ); 416 417 /** 418 * \brief This function updates the state of the CTR_DRBG context. 419 * 420 * \note This function is not thread-safe. It is not safe 421 * to call this function if another thread might be 422 * concurrently obtaining random numbers from the same 423 * context or updating or reseeding the same 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 * \note This function is not thread-safe. It is not safe 449 * to call this function if another thread might be 450 * concurrently obtaining random numbers from the same 451 * context or updating or reseeding the same context. 452 * 453 * \param p_rng The CTR_DRBG context. This must be a pointer to a 454 * #mbedtls_ctr_drbg_context structure. 455 * \param output The buffer to fill. 456 * \param output_len The length of the buffer in bytes. 457 * \param additional Additional data to update. Can be \c NULL, in which 458 * case the additional data is empty regardless of 459 * the value of \p add_len. 460 * \param add_len The length of the additional data 461 * if \p additional is not \c NULL. 462 * This must be less than #MBEDTLS_CTR_DRBG_MAX_INPUT 463 * and less than 464 * #MBEDTLS_CTR_DRBG_MAX_SEED_INPUT - \c entropy_len 465 * where \c entropy_len is the entropy length 466 * configured for the context. 467 * 468 * \return \c 0 on success. 469 * \return #MBEDTLS_ERR_CTR_DRBG_ENTROPY_SOURCE_FAILED or 470 * #MBEDTLS_ERR_CTR_DRBG_REQUEST_TOO_BIG on failure. 471 */ 472 int mbedtls_ctr_drbg_random_with_add( void *p_rng, 473 unsigned char *output, size_t output_len, 474 const unsigned char *additional, size_t add_len ); 475 476 /** 477 * \brief This function uses CTR_DRBG to generate random data. 478 * 479 * This function automatically reseeds if the reseed counter is exceeded 480 * or prediction resistance is enabled. 481 */ 482 #if defined(MBEDTLS_THREADING_C) 483 /** 484 * \note When Mbed TLS is built with threading support, 485 * it is safe to call mbedtls_ctr_drbg_random() 486 * from multiple threads. Other operations, including 487 * reseeding, are not thread-safe. 488 */ 489 #endif /* MBEDTLS_THREADING_C */ 490 /** 491 * \param p_rng The CTR_DRBG context. This must be a pointer to a 492 * #mbedtls_ctr_drbg_context structure. 493 * \param output The buffer to fill. 494 * \param output_len The length of the buffer in bytes. 495 * 496 * \return \c 0 on success. 497 * \return #MBEDTLS_ERR_CTR_DRBG_ENTROPY_SOURCE_FAILED or 498 * #MBEDTLS_ERR_CTR_DRBG_REQUEST_TOO_BIG on failure. 499 */ 500 int mbedtls_ctr_drbg_random( void *p_rng, 501 unsigned char *output, size_t output_len ); 502 503 504 #if ! defined(MBEDTLS_DEPRECATED_REMOVED) 505 #if defined(MBEDTLS_DEPRECATED_WARNING) 506 #define MBEDTLS_DEPRECATED __attribute__((deprecated)) 507 #else 508 #define MBEDTLS_DEPRECATED 509 #endif 510 /** 511 * \brief This function updates the state of the CTR_DRBG context. 512 * 513 * \deprecated Superseded by mbedtls_ctr_drbg_update_ret() 514 * in 2.16.0. 515 * 516 * \note If \p add_len is greater than 517 * #MBEDTLS_CTR_DRBG_MAX_SEED_INPUT, only the first 518 * #MBEDTLS_CTR_DRBG_MAX_SEED_INPUT Bytes are used. 519 * The remaining Bytes are silently discarded. 520 * 521 * \param ctx The CTR_DRBG context. 522 * \param additional The data to update the state with. 523 * \param add_len Length of \p additional data. 524 */ 525 MBEDTLS_DEPRECATED void mbedtls_ctr_drbg_update( 526 mbedtls_ctr_drbg_context *ctx, 527 const unsigned char *additional, 528 size_t add_len ); 529 #undef MBEDTLS_DEPRECATED 530 #endif /* !MBEDTLS_DEPRECATED_REMOVED */ 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 /* Internal functions (do not call directly) */ 576 int mbedtls_ctr_drbg_seed_entropy_len( mbedtls_ctr_drbg_context *, 577 int (*)(void *, unsigned char *, size_t), void *, 578 const unsigned char *, size_t, size_t ); 579 580 #ifdef __cplusplus 581 } 582 #endif 583 584 #endif /* ctr_drbg.h */ 585