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