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