NCBI C++ ToolKit
ctr_drbg.h
Go to the documentation of this file.

Go to the SVN repository for this file.

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 /* In case AES_C is defined then it is the primary option for backward
36  * compatibility purposes. If that's not available, PSA is used instead */
37 #if defined(MBEDTLS_AES_C)
38 #include "mbedtls/aes.h"
39 #else
40 #include "psa/crypto.h"
41 #endif
42 
43 #include "entropy.h"
44 
45 #if defined(MBEDTLS_THREADING_C)
46 #include "mbedtls/threading.h"
47 #endif
48 
49 /** The entropy source failed. */
50 #define MBEDTLS_ERR_CTR_DRBG_ENTROPY_SOURCE_FAILED -0x0034
51 /** The requested random buffer length is too big. */
52 #define MBEDTLS_ERR_CTR_DRBG_REQUEST_TOO_BIG -0x0036
53 /** The input (entropy + additional data) is too large. */
54 #define MBEDTLS_ERR_CTR_DRBG_INPUT_TOO_BIG -0x0038
55 /** Read or write error in file. */
56 #define MBEDTLS_ERR_CTR_DRBG_FILE_IO_ERROR -0x003A
57 
58 #define MBEDTLS_CTR_DRBG_BLOCKSIZE 16 /**< The block size used by the cipher. */
59 
60 #if defined(MBEDTLS_CTR_DRBG_USE_128_BIT_KEY)
61 #define MBEDTLS_CTR_DRBG_KEYSIZE 16
62 /**< The key size in bytes used by the cipher.
63  *
64  * Compile-time choice: 16 bytes (128 bits)
65  * because #MBEDTLS_CTR_DRBG_USE_128_BIT_KEY is enabled.
66  */
67 #else
68 #define MBEDTLS_CTR_DRBG_KEYSIZE 32
69 /**< The key size in bytes used by the cipher.
70  *
71  * Compile-time choice: 32 bytes (256 bits)
72  * because \c MBEDTLS_CTR_DRBG_USE_128_BIT_KEY is disabled.
73  */
74 #endif
75 
76 #define MBEDTLS_CTR_DRBG_KEYBITS (MBEDTLS_CTR_DRBG_KEYSIZE * 8) /**< The key size for the DRBG operation, in bits. */
77 #define MBEDTLS_CTR_DRBG_SEEDLEN (MBEDTLS_CTR_DRBG_KEYSIZE + MBEDTLS_CTR_DRBG_BLOCKSIZE) /**< The seed length, calculated as (counter + AES key). */
78 
79 /**
80  * \name SECTION: Module settings
81  *
82  * The configuration options you can set for this module are in this section.
83  * Either change them in mbedtls_config.h or define them using the compiler command
84  * line.
85  * \{
86  */
87 
88 /** \def MBEDTLS_CTR_DRBG_ENTROPY_LEN
89  *
90  * \brief The amount of entropy used per seed by default, in bytes.
91  */
92 #if !defined(MBEDTLS_CTR_DRBG_ENTROPY_LEN)
93 #if defined(MBEDTLS_ENTROPY_SHA512_ACCUMULATOR)
94 /** This is 48 bytes because the entropy module uses SHA-512.
95  */
96 #define MBEDTLS_CTR_DRBG_ENTROPY_LEN 48
97 
98 #else /* MBEDTLS_ENTROPY_SHA512_ACCUMULATOR */
99 
100 /** This is 32 bytes because the entropy module uses SHA-256.
101  */
102 #if !defined(MBEDTLS_CTR_DRBG_USE_128_BIT_KEY)
103 /** \warning To achieve a 256-bit security strength, you must pass a nonce
104  * to mbedtls_ctr_drbg_seed().
105  */
106 #endif /* !defined(MBEDTLS_CTR_DRBG_USE_128_BIT_KEY) */
107 #define MBEDTLS_CTR_DRBG_ENTROPY_LEN 32
108 #endif /* MBEDTLS_ENTROPY_SHA512_ACCUMULATOR */
109 #endif /* !defined(MBEDTLS_CTR_DRBG_ENTROPY_LEN) */
110 
111 #if !defined(MBEDTLS_CTR_DRBG_RESEED_INTERVAL)
112 #define MBEDTLS_CTR_DRBG_RESEED_INTERVAL 10000
113 /**< The interval before reseed is performed by default. */
114 #endif
115 
116 #if !defined(MBEDTLS_CTR_DRBG_MAX_INPUT)
117 #define MBEDTLS_CTR_DRBG_MAX_INPUT 256
118 /**< The maximum number of additional input Bytes. */
119 #endif
120 
121 #if !defined(MBEDTLS_CTR_DRBG_MAX_REQUEST)
122 #define MBEDTLS_CTR_DRBG_MAX_REQUEST 1024
123 /**< The maximum number of requested Bytes per call. */
124 #endif
125 
126 #if !defined(MBEDTLS_CTR_DRBG_MAX_SEED_INPUT)
127 #define MBEDTLS_CTR_DRBG_MAX_SEED_INPUT 384
128 /**< The maximum size of seed or reseed buffer in bytes. */
129 #endif
130 
131 /** \} name SECTION: Module settings */
132 
133 #define MBEDTLS_CTR_DRBG_PR_OFF 0
134 /**< Prediction resistance is disabled. */
135 #define MBEDTLS_CTR_DRBG_PR_ON 1
136 /**< Prediction resistance is enabled. */
137 
138 #ifdef __cplusplus
139 extern "C" {
140 #endif
141 
142 #if MBEDTLS_CTR_DRBG_ENTROPY_LEN >= MBEDTLS_CTR_DRBG_KEYSIZE * 3 / 2
143 /** The default length of the nonce read from the entropy source.
144  *
145  * This is \c 0 because a single read from the entropy source is sufficient
146  * to include a nonce.
147  * See the documentation of mbedtls_ctr_drbg_seed() for more information.
148  */
149 #define MBEDTLS_CTR_DRBG_ENTROPY_NONCE_LEN 0
150 #else
151 /** The default length of the nonce read from the entropy source.
152  *
153  * This is half of the default entropy length because a single read from
154  * the entropy source does not provide enough material to form a nonce.
155  * See the documentation of mbedtls_ctr_drbg_seed() for more information.
156  */
157 #define MBEDTLS_CTR_DRBG_ENTROPY_NONCE_LEN (MBEDTLS_CTR_DRBG_ENTROPY_LEN + 1) / 2
158 #endif
159 
160 #if !defined(MBEDTLS_AES_C)
165 #endif
166 
167 /**
168  * \brief The CTR_DRBG context structure.
169  */
170 typedef struct mbedtls_ctr_drbg_context {
171  unsigned char MBEDTLS_PRIVATE(counter)[16]; /*!< The counter (V). */
172  int MBEDTLS_PRIVATE(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 MBEDTLS_PRIVATE(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 MBEDTLS_PRIVATE(entropy_len); /*!< The amount of entropy grabbed on each
187  seed or reseed operation, in bytes. */
188  int MBEDTLS_PRIVATE(reseed_interval); /*!< The reseed interval.
189  * This is the maximum number of requests
190  * that can be made between reseedings. */
191 
192 #if defined(MBEDTLS_AES_C)
193  mbedtls_aes_context MBEDTLS_PRIVATE(aes_ctx); /*!< The AES context. */
194 #else
195  mbedtls_ctr_drbg_psa_context MBEDTLS_PRIVATE(psa_ctx); /*!< The PSA context. */
196 #endif
197 
198  /*
199  * Callbacks (Entropy)
200  */
201  int(*MBEDTLS_PRIVATE(f_entropy))(void *, unsigned char *, size_t);
202  /*!< The entropy callback function. */
203 
204  void *MBEDTLS_PRIVATE(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  */
215 #endif
216 }
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  */
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  */
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  */
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  */
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  */
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  */
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  */
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  */
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  */
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  */
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 #if defined(MBEDTLS_FS_IO)
536 /**
537  * \brief This function writes a seed file.
538  *
539  * \param ctx The CTR_DRBG context.
540  * \param path The name of the file.
541  *
542  * \return \c 0 on success.
543  * \return #MBEDTLS_ERR_CTR_DRBG_FILE_IO_ERROR on file error.
544  * \return #MBEDTLS_ERR_CTR_DRBG_ENTROPY_SOURCE_FAILED on reseed
545  * failure.
546  */
548 
549 /**
550  * \brief This function reads and updates a seed file. The seed
551  * is added to this instance.
552  *
553  * \param ctx The CTR_DRBG context.
554  * \param path The name of the file.
555  *
556  * \return \c 0 on success.
557  * \return #MBEDTLS_ERR_CTR_DRBG_FILE_IO_ERROR on file error.
558  * \return #MBEDTLS_ERR_CTR_DRBG_ENTROPY_SOURCE_FAILED on
559  * reseed failure.
560  * \return #MBEDTLS_ERR_CTR_DRBG_INPUT_TOO_BIG if the existing
561  * seed file is too large.
562  */
564 #endif /* MBEDTLS_FS_IO */
565 
566 #if defined(MBEDTLS_SELF_TEST)
567 
568 /**
569  * \brief The CTR_DRBG checkup routine.
570  *
571  * \return \c 0 on success.
572  * \return \c 1 on failure.
573  */
574 int mbedtls_ctr_drbg_self_test(int verbose);
575 
576 #endif /* MBEDTLS_SELF_TEST */
577 
578 #ifdef __cplusplus
579 }
580 #endif
581 
582 #endif /* ctr_drbg.h */
This file contains AES definitions and functions.
Platform Security Architecture cryptography module.
int mbedtls_ctr_drbg_set_nonce_len(mbedtls_ctr_drbg_context *ctx, size_t len)
This function sets the amount of entropy grabbed as a nonce for the initial seeding.
int mbedtls_ctr_drbg_random_with_add(void *p_rng, unsigned char *output, size_t output_len, const unsigned char *additional, size_t add_len)
This function updates a CTR_DRBG instance with additional data and uses it to generate random data.
void mbedtls_ctr_drbg_free(mbedtls_ctr_drbg_context *ctx)
This function resets CTR_DRBG context to the state immediately after initial call of mbedtls_ctr_drbg...
int mbedtls_ctr_drbg_reseed(mbedtls_ctr_drbg_context *ctx, const unsigned char *additional, size_t len)
This function reseeds the CTR_DRBG context, that is extracts data from the entropy source.
struct mbedtls_ctr_drbg_context mbedtls_ctr_drbg_context
The CTR_DRBG context structure.
void mbedtls_ctr_drbg_init(mbedtls_ctr_drbg_context *ctx)
This function initializes the CTR_DRBG context, and prepares it for mbedtls_ctr_drbg_seed() or mbedtl...
int mbedtls_ctr_drbg_update(mbedtls_ctr_drbg_context *ctx, const unsigned char *additional, size_t add_len)
This function updates the state of the CTR_DRBG context.
int mbedtls_ctr_drbg_seed(mbedtls_ctr_drbg_context *ctx, int(*f_entropy)(void *, unsigned char *, size_t), void *p_entropy, const unsigned char *custom, size_t len)
This function seeds and sets up the CTR_DRBG entropy source for future reseeds.
void mbedtls_ctr_drbg_set_prediction_resistance(mbedtls_ctr_drbg_context *ctx, int resistance)
This function turns prediction resistance on or off.
void mbedtls_ctr_drbg_set_reseed_interval(mbedtls_ctr_drbg_context *ctx, int interval)
This function sets the reseed interval.
void mbedtls_ctr_drbg_set_entropy_len(mbedtls_ctr_drbg_context *ctx, size_t len)
This function sets the amount of entropy grabbed on each seed or reseed.
int mbedtls_ctr_drbg_random(void *p_rng, unsigned char *output, size_t output_len)
This function uses CTR_DRBG to generate random data.
struct mbedtls_ctr_drbg_psa_context mbedtls_ctr_drbg_psa_context
Entropy accumulator implementation.
CS_CONTEXT * ctx
Definition: t0006.c:12
static SQLCHAR output[256]
Definition: print.c:5
psa_key_id_t mbedtls_svc_key_id_t
Encoding of key identifiers as seen inside the PSA Crypto implementation.
Definition: crypto_types.h:292
unsigned int
A callback function used to compare two keys in a database.
Definition: types.hpp:1210
int len
Build-time configuration info.
#define mbedtls_ctr_drbg_write_seed_file
#define mbedtls_ctr_drbg_update_seed_file
Macro wrapper for struct's members.
true_type verbose
Definition: processing.cpp:890
The AES context-type definition.
Definition: aes.h:63
The CTR_DRBG context structure.
Definition: ctr_drbg.h:170
size_t MBEDTLS_PRIVATE(entropy_len)
int(*)(void *, unsigned char *, size_t) MBEDTLS_PRIVATE(f_entropy)
Definition: ctr_drbg.h:201
void * MBEDTLS_PRIVATE(p_entropy)
mbedtls_ctr_drbg_psa_context MBEDTLS_PRIVATE(psa_ctx)
int MBEDTLS_PRIVATE(reseed_interval)
int MBEDTLS_PRIVATE(prediction_resistance)
int MBEDTLS_PRIVATE(reseed_counter)
unsigned char MBEDTLS_PRIVATE(counter)[16]
psa_cipher_operation_t operation
Definition: ctr_drbg.h:163
mbedtls_svc_key_id_t key_id
Definition: ctr_drbg.h:162
Threading abstraction layer.
Modified on Sun Jun 23 05:16:41 2024 by modify_doxy.py rev. 669887