1 /** 2 * \file config.h 3 * 4 * \brief Configuration options (set of defines) 5 * 6 * This set of compile-time options may be used to enable 7 * or disable features selectively, and reduce the global 8 * memory footprint. 9 */ 10 /* 11 * Copyright The Mbed TLS Contributors 12 * SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later 13 */ 14 15 #ifndef MBEDTLS_CONFIG_H 16 #define MBEDTLS_CONFIG_H 17 18 #if defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE) 19 #define _CRT_SECURE_NO_DEPRECATE 1 20 #endif 21 22 /** 23 * \name SECTION: System support 24 * 25 * This section sets system specific settings. 26 * \{ 27 */ 28 29 /** 30 * \def MBEDTLS_HAVE_ASM 31 * 32 * The compiler has support for asm(). 33 * 34 * Requires support for asm() in compiler. 35 * 36 * Used in: 37 * library/aria.c 38 * library/timing.c 39 * include/mbedtls/bn_mul.h 40 * 41 * Required by: 42 * MBEDTLS_AESNI_C (on some platforms) 43 * MBEDTLS_PADLOCK_C 44 * 45 * Comment to disable the use of assembly code. 46 */ 47 #define MBEDTLS_HAVE_ASM 48 49 /** 50 * \def MBEDTLS_NO_UDBL_DIVISION 51 * 52 * The platform lacks support for double-width integer division (64-bit 53 * division on a 32-bit platform, 128-bit division on a 64-bit platform). 54 * 55 * Used in: 56 * include/mbedtls/bignum.h 57 * library/bignum.c 58 * 59 * The bignum code uses double-width division to speed up some operations. 60 * Double-width division is often implemented in software that needs to 61 * be linked with the program. The presence of a double-width integer 62 * type is usually detected automatically through preprocessor macros, 63 * but the automatic detection cannot know whether the code needs to 64 * and can be linked with an implementation of division for that type. 65 * By default division is assumed to be usable if the type is present. 66 * Uncomment this option to prevent the use of double-width division. 67 * 68 * Note that division for the native integer type is always required. 69 * Furthermore, a 64-bit type is always required even on a 32-bit 70 * platform, but it need not support multiplication or division. In some 71 * cases it is also desirable to disable some double-width operations. For 72 * example, if double-width division is implemented in software, disabling 73 * it can reduce code size in some embedded targets. 74 */ 75 //#define MBEDTLS_NO_UDBL_DIVISION 76 77 /** 78 * \def MBEDTLS_NO_64BIT_MULTIPLICATION 79 * 80 * The platform lacks support for 32x32 -> 64-bit multiplication. 81 * 82 * Used in: 83 * library/poly1305.c 84 * 85 * Some parts of the library may use multiplication of two unsigned 32-bit 86 * operands with a 64-bit result in order to speed up computations. On some 87 * platforms, this is not available in hardware and has to be implemented in 88 * software, usually in a library provided by the toolchain. 89 * 90 * Sometimes it is not desirable to have to link to that library. This option 91 * removes the dependency of that library on platforms that lack a hardware 92 * 64-bit multiplier by embedding a software implementation in Mbed TLS. 93 * 94 * Note that depending on the compiler, this may decrease performance compared 95 * to using the library function provided by the toolchain. 96 */ 97 //#define MBEDTLS_NO_64BIT_MULTIPLICATION 98 99 /** 100 * \def MBEDTLS_HAVE_SSE2 101 * 102 * CPU supports SSE2 instruction set. 103 * 104 * Uncomment if the CPU supports SSE2 (IA-32 specific). 105 */ 106 //#define MBEDTLS_HAVE_SSE2 107 108 /** 109 * \def MBEDTLS_HAVE_TIME 110 * 111 * System has time.h and time(). 112 * The time does not need to be correct, only time differences are used, 113 * by contrast with MBEDTLS_HAVE_TIME_DATE 114 * 115 * Defining MBEDTLS_HAVE_TIME allows you to specify MBEDTLS_PLATFORM_TIME_ALT, 116 * MBEDTLS_PLATFORM_TIME_MACRO, MBEDTLS_PLATFORM_TIME_TYPE_MACRO and 117 * MBEDTLS_PLATFORM_STD_TIME. 118 * 119 * Comment if your system does not support time functions. 120 * 121 * \note If MBEDTLS_TIMING_C is set - to enable the semi-portable timing 122 * interface - timing.c will include time.h on suitable platforms 123 * regardless of the setting of MBEDTLS_HAVE_TIME, unless 124 * MBEDTLS_TIMING_ALT is used. See timing.c for more information. 125 */ 126 #define MBEDTLS_HAVE_TIME 127 128 /** 129 * \def MBEDTLS_HAVE_TIME_DATE 130 * 131 * System has time.h, time(), and an implementation for 132 * mbedtls_platform_gmtime_r() (see below). 133 * The time needs to be correct (not necessarily very accurate, but at least 134 * the date should be correct). This is used to verify the validity period of 135 * X.509 certificates. 136 * 137 * Comment if your system does not have a correct clock. 138 * 139 * \note mbedtls_platform_gmtime_r() is an abstraction in platform_util.h that 140 * behaves similarly to the gmtime_r() function from the C standard. Refer to 141 * the documentation for mbedtls_platform_gmtime_r() for more information. 142 * 143 * \note It is possible to configure an implementation for 144 * mbedtls_platform_gmtime_r() at compile-time by using the macro 145 * MBEDTLS_PLATFORM_GMTIME_R_ALT. 146 */ 147 #define MBEDTLS_HAVE_TIME_DATE 148 149 /** 150 * \def MBEDTLS_PLATFORM_MEMORY 151 * 152 * Enable the memory allocation layer. 153 * 154 * By default Mbed TLS uses the system-provided calloc() and free(). 155 * This allows different allocators (self-implemented or provided) to be 156 * provided to the platform abstraction layer. 157 * 158 * Enabling #MBEDTLS_PLATFORM_MEMORY without the 159 * MBEDTLS_PLATFORM_{FREE,CALLOC}_MACROs will provide 160 * "mbedtls_platform_set_calloc_free()" allowing you to set an alternative calloc() and 161 * free() function pointer at runtime. 162 * 163 * Enabling #MBEDTLS_PLATFORM_MEMORY and specifying 164 * MBEDTLS_PLATFORM_{CALLOC,FREE}_MACROs will allow you to specify the 165 * alternate function at compile time. 166 * 167 * An overview of how the value of mbedtls_calloc is determined: 168 * 169 * - if !MBEDTLS_PLATFORM_MEMORY 170 * - mbedtls_calloc = calloc 171 * - if MBEDTLS_PLATFORM_MEMORY 172 * - if (MBEDTLS_PLATFORM_CALLOC_MACRO && MBEDTLS_PLATFORM_FREE_MACRO): 173 * - mbedtls_calloc = MBEDTLS_PLATFORM_CALLOC_MACRO 174 * - if !(MBEDTLS_PLATFORM_CALLOC_MACRO && MBEDTLS_PLATFORM_FREE_MACRO): 175 * - Dynamic setup via mbedtls_platform_set_calloc_free is now possible with a default value MBEDTLS_PLATFORM_STD_CALLOC. 176 * - How is MBEDTLS_PLATFORM_STD_CALLOC handled? 177 * - if MBEDTLS_PLATFORM_NO_STD_FUNCTIONS: 178 * - MBEDTLS_PLATFORM_STD_CALLOC is not set to anything; 179 * - MBEDTLS_PLATFORM_STD_MEM_HDR can be included if present; 180 * - if !MBEDTLS_PLATFORM_NO_STD_FUNCTIONS: 181 * - if MBEDTLS_PLATFORM_STD_CALLOC is present: 182 * - User-defined MBEDTLS_PLATFORM_STD_CALLOC is respected; 183 * - if !MBEDTLS_PLATFORM_STD_CALLOC: 184 * - MBEDTLS_PLATFORM_STD_CALLOC = calloc 185 * 186 * - At this point the presence of MBEDTLS_PLATFORM_STD_CALLOC is checked. 187 * - if !MBEDTLS_PLATFORM_STD_CALLOC 188 * - MBEDTLS_PLATFORM_STD_CALLOC = uninitialized_calloc 189 * 190 * - mbedtls_calloc = MBEDTLS_PLATFORM_STD_CALLOC. 191 * 192 * Defining MBEDTLS_PLATFORM_CALLOC_MACRO and #MBEDTLS_PLATFORM_STD_CALLOC at the same time is not possible. 193 * MBEDTLS_PLATFORM_CALLOC_MACRO and MBEDTLS_PLATFORM_FREE_MACRO must both be defined or undefined at the same time. 194 * #MBEDTLS_PLATFORM_STD_CALLOC and #MBEDTLS_PLATFORM_STD_FREE do not have to be defined at the same time, as, if they are used, 195 * dynamic setup of these functions is possible. See the tree above to see how are they handled in all cases. 196 * An uninitialized #MBEDTLS_PLATFORM_STD_CALLOC always fails, returning a null pointer. 197 * An uninitialized #MBEDTLS_PLATFORM_STD_FREE does not do anything. 198 * 199 * Requires: MBEDTLS_PLATFORM_C 200 * 201 * Enable this layer to allow use of alternative memory allocators. 202 */ 203 //#define MBEDTLS_PLATFORM_MEMORY 204 205 /** 206 * \def MBEDTLS_PLATFORM_NO_STD_FUNCTIONS 207 * 208 * Do not assign standard functions in the platform layer (e.g. calloc() to 209 * MBEDTLS_PLATFORM_STD_CALLOC and printf() to MBEDTLS_PLATFORM_STD_PRINTF) 210 * 211 * This makes sure there are no linking errors on platforms that do not support 212 * these functions. You will HAVE to provide alternatives, either at runtime 213 * via the platform_set_xxx() functions or at compile time by setting 214 * the MBEDTLS_PLATFORM_STD_XXX defines, or enabling a 215 * MBEDTLS_PLATFORM_XXX_MACRO. 216 * 217 * Requires: MBEDTLS_PLATFORM_C 218 * 219 * Uncomment to prevent default assignment of standard functions in the 220 * platform layer. 221 */ 222 //#define MBEDTLS_PLATFORM_NO_STD_FUNCTIONS 223 224 /** 225 * \def MBEDTLS_PLATFORM_EXIT_ALT 226 * 227 * MBEDTLS_PLATFORM_XXX_ALT: Uncomment a macro to let Mbed TLS support the 228 * function in the platform abstraction layer. 229 * 230 * Example: In case you uncomment MBEDTLS_PLATFORM_PRINTF_ALT, Mbed TLS will 231 * provide a function "mbedtls_platform_set_printf()" that allows you to set an 232 * alternative printf function pointer. 233 * 234 * All these define require MBEDTLS_PLATFORM_C to be defined! 235 * 236 * \note MBEDTLS_PLATFORM_SNPRINTF_ALT is required on Windows; 237 * it will be enabled automatically by check_config.h 238 * 239 * \warning MBEDTLS_PLATFORM_XXX_ALT cannot be defined at the same time as 240 * MBEDTLS_PLATFORM_XXX_MACRO! 241 * 242 * Requires: MBEDTLS_PLATFORM_TIME_ALT requires MBEDTLS_HAVE_TIME 243 * 244 * Uncomment a macro to enable alternate implementation of specific base 245 * platform function 246 */ 247 //#define MBEDTLS_PLATFORM_EXIT_ALT 248 //#define MBEDTLS_PLATFORM_TIME_ALT 249 //#define MBEDTLS_PLATFORM_FPRINTF_ALT 250 //#define MBEDTLS_PLATFORM_PRINTF_ALT 251 //#define MBEDTLS_PLATFORM_SNPRINTF_ALT 252 //#define MBEDTLS_PLATFORM_VSNPRINTF_ALT 253 //#define MBEDTLS_PLATFORM_NV_SEED_ALT 254 //#define MBEDTLS_PLATFORM_SETUP_TEARDOWN_ALT 255 256 /** 257 * Uncomment the macro to let Mbed TLS use your alternate implementation of 258 * mbedtls_platform_gmtime_r(). This replaces the default implementation in 259 * platform_util.c. 260 * 261 * gmtime() is not a thread-safe function as defined in the C standard. The 262 * library will try to use safer implementations of this function, such as 263 * gmtime_r() when available. However, if Mbed TLS cannot identify the target 264 * system, the implementation of mbedtls_platform_gmtime_r() will default to 265 * using the standard gmtime(). In this case, calls from the library to 266 * gmtime() will be guarded by the global mutex mbedtls_threading_gmtime_mutex 267 * if MBEDTLS_THREADING_C is enabled. We recommend that calls from outside the 268 * library are also guarded with this mutex to avoid race conditions. However, 269 * if the macro MBEDTLS_PLATFORM_GMTIME_R_ALT is defined, Mbed TLS will 270 * unconditionally use the implementation for mbedtls_platform_gmtime_r() 271 * supplied at compile time. 272 */ 273 //#define MBEDTLS_PLATFORM_GMTIME_R_ALT 274 275 /** 276 * Uncomment the macro to let Mbed TLS use your alternate implementation of 277 * mbedtls_platform_zeroize(). This replaces the default implementation in 278 * platform_util.c. 279 * 280 * mbedtls_platform_zeroize() is a widely used function across the library to 281 * zero a block of memory. The implementation is expected to be secure in the 282 * sense that it has been written to prevent the compiler from removing calls 283 * to mbedtls_platform_zeroize() as part of redundant code elimination 284 * optimizations. However, it is difficult to guarantee that calls to 285 * mbedtls_platform_zeroize() will not be optimized by the compiler as older 286 * versions of the C language standards do not provide a secure implementation 287 * of memset(). Therefore, MBEDTLS_PLATFORM_ZEROIZE_ALT enables users to 288 * configure their own implementation of mbedtls_platform_zeroize(), for 289 * example by using directives specific to their compiler, features from newer 290 * C standards (e.g using memset_s() in C11) or calling a secure memset() from 291 * their system (e.g explicit_bzero() in BSD). 292 */ 293 //#define MBEDTLS_PLATFORM_ZEROIZE_ALT 294 295 /** 296 * \def MBEDTLS_DEPRECATED_WARNING 297 * 298 * Mark deprecated functions and features so that they generate a warning if 299 * used. Functionality deprecated in one version will usually be removed in the 300 * next version. You can enable this to help you prepare the transition to a 301 * new major version by making sure your code is not using this functionality. 302 * 303 * This only works with GCC and Clang. With other compilers, you may want to 304 * use MBEDTLS_DEPRECATED_REMOVED 305 * 306 * Uncomment to get warnings on using deprecated functions and features. 307 */ 308 //#define MBEDTLS_DEPRECATED_WARNING 309 310 /** 311 * \def MBEDTLS_DEPRECATED_REMOVED 312 * 313 * Remove deprecated functions and features so that they generate an error if 314 * used. Functionality deprecated in one version will usually be removed in the 315 * next version. You can enable this to help you prepare the transition to a 316 * new major version by making sure your code is not using this functionality. 317 * 318 * Uncomment to get errors on using deprecated functions and features. 319 */ 320 //#define MBEDTLS_DEPRECATED_REMOVED 321 322 /** 323 * \def MBEDTLS_CHECK_PARAMS 324 * 325 * This configuration option controls whether the library validates more of 326 * the parameters passed to it. 327 * 328 * When this flag is not defined, the library only attempts to validate an 329 * input parameter if: (1) they may come from the outside world (such as the 330 * network, the filesystem, etc.) or (2) not validating them could result in 331 * internal memory errors such as overflowing a buffer controlled by the 332 * library. On the other hand, it doesn't attempt to validate parameters whose 333 * values are fully controlled by the application (such as pointers). 334 * 335 * When this flag is defined, the library additionally attempts to validate 336 * parameters that are fully controlled by the application, and should always 337 * be valid if the application code is fully correct and trusted. 338 * 339 * For example, when a function accepts as input a pointer to a buffer that may 340 * contain untrusted data, and its documentation mentions that this pointer 341 * must not be NULL: 342 * - The pointer is checked to be non-NULL only if this option is enabled. 343 * - The content of the buffer is always validated. 344 * 345 * When this flag is defined, if a library function receives a parameter that 346 * is invalid: 347 * 1. The function will invoke the macro MBEDTLS_PARAM_FAILED(). 348 * 2. If MBEDTLS_PARAM_FAILED() did not terminate the program, the function 349 * will immediately return. If the function returns an Mbed TLS error code, 350 * the error code in this case is MBEDTLS_ERR_xxx_BAD_INPUT_DATA. 351 * 352 * When defining this flag, you also need to arrange a definition for 353 * MBEDTLS_PARAM_FAILED(). You can do this by any of the following methods: 354 * - By default, the library defines MBEDTLS_PARAM_FAILED() to call a 355 * function mbedtls_param_failed(), but the library does not define this 356 * function. If you do not make any other arrangements, you must provide 357 * the function mbedtls_param_failed() in your application. 358 * See `platform_util.h` for its prototype. 359 * - If you enable the macro #MBEDTLS_CHECK_PARAMS_ASSERT, then the 360 * library defines MBEDTLS_PARAM_FAILED(\c cond) to be `assert(cond)`. 361 * You can still supply an alternative definition of 362 * MBEDTLS_PARAM_FAILED(), which may call `assert`. 363 * - If you define a macro MBEDTLS_PARAM_FAILED() before including `config.h` 364 * or you uncomment the definition of MBEDTLS_PARAM_FAILED() in `config.h`, 365 * the library will call the macro that you defined and will not supply 366 * its own version. Note that if MBEDTLS_PARAM_FAILED() calls `assert`, 367 * you need to enable #MBEDTLS_CHECK_PARAMS_ASSERT so that library source 368 * files include `<assert.h>`. 369 * 370 * Uncomment to enable validation of application-controlled parameters. 371 */ 372 //#define MBEDTLS_CHECK_PARAMS 373 374 /** 375 * \def MBEDTLS_CHECK_PARAMS_ASSERT 376 * 377 * Allow MBEDTLS_PARAM_FAILED() to call `assert`, and make it default to 378 * `assert`. This macro is only used if #MBEDTLS_CHECK_PARAMS is defined. 379 * 380 * If this macro is not defined, then MBEDTLS_PARAM_FAILED() defaults to 381 * calling a function mbedtls_param_failed(). See the documentation of 382 * #MBEDTLS_CHECK_PARAMS for details. 383 * 384 * Uncomment to allow MBEDTLS_PARAM_FAILED() to call `assert`. 385 */ 386 //#define MBEDTLS_CHECK_PARAMS_ASSERT 387 388 /** \} name SECTION: System support */ 389 390 /** 391 * \name SECTION: Mbed TLS feature support 392 * 393 * This section sets support for features that are or are not needed 394 * within the modules that are enabled. 395 * \{ 396 */ 397 398 /** 399 * \def MBEDTLS_TIMING_ALT 400 * 401 * Uncomment to provide your own alternate implementation for mbedtls_timing_hardclock(), 402 * mbedtls_timing_get_timer(), mbedtls_set_alarm(), mbedtls_set/get_delay() 403 * 404 * Only works if you have MBEDTLS_TIMING_C enabled. 405 * 406 * You will need to provide a header "timing_alt.h" and an implementation at 407 * compile time. 408 */ 409 //#define MBEDTLS_TIMING_ALT 410 411 /** 412 * \def MBEDTLS_AES_ALT 413 * 414 * MBEDTLS__MODULE_NAME__ALT: Uncomment a macro to let Mbed TLS use your 415 * alternate core implementation of a symmetric crypto, an arithmetic or hash 416 * module (e.g. platform specific assembly optimized implementations). Keep 417 * in mind that the function prototypes should remain the same. 418 * 419 * This replaces the whole module. If you only want to replace one of the 420 * functions, use one of the MBEDTLS__FUNCTION_NAME__ALT flags. 421 * 422 * Example: In case you uncomment MBEDTLS_AES_ALT, Mbed TLS will no longer 423 * provide the "struct mbedtls_aes_context" definition and omit the base 424 * function declarations and implementations. "aes_alt.h" will be included from 425 * "aes.h" to include the new function definitions. 426 * 427 * Uncomment a macro to enable alternate implementation of the corresponding 428 * module. 429 * 430 * \warning MD2, MD4, MD5, ARC4, DES and SHA-1 are considered weak and their 431 * use constitutes a security risk. If possible, we recommend 432 * avoiding dependencies on them, and considering stronger message 433 * digests and ciphers instead. 434 * 435 */ 436 //#define MBEDTLS_AES_ALT 437 //#define MBEDTLS_ARC4_ALT 438 //#define MBEDTLS_ARIA_ALT 439 //#define MBEDTLS_BLOWFISH_ALT 440 //#define MBEDTLS_CAMELLIA_ALT 441 //#define MBEDTLS_CCM_ALT 442 //#define MBEDTLS_CHACHA20_ALT 443 //#define MBEDTLS_CHACHAPOLY_ALT 444 //#define MBEDTLS_CMAC_ALT 445 //#define MBEDTLS_DES_ALT 446 //#define MBEDTLS_DHM_ALT 447 //#define MBEDTLS_ECJPAKE_ALT 448 //#define MBEDTLS_GCM_ALT 449 //#define MBEDTLS_NIST_KW_ALT 450 //#define MBEDTLS_MD2_ALT 451 //#define MBEDTLS_MD4_ALT 452 //#define MBEDTLS_MD5_ALT 453 //#define MBEDTLS_POLY1305_ALT 454 //#define MBEDTLS_RIPEMD160_ALT 455 //#define MBEDTLS_RSA_ALT 456 //#define MBEDTLS_SHA1_ALT 457 //#define MBEDTLS_SHA256_ALT 458 //#define MBEDTLS_SHA512_ALT 459 //#define MBEDTLS_XTEA_ALT 460 461 /* 462 * When replacing the elliptic curve module, please consider, that it is 463 * implemented with two .c files: 464 * - ecp.c 465 * - ecp_curves.c 466 * You can replace them very much like all the other MBEDTLS__MODULE_NAME__ALT 467 * macros as described above. The only difference is that you have to make sure 468 * that you provide functionality for both .c files. 469 */ 470 //#define MBEDTLS_ECP_ALT 471 472 /** 473 * \def MBEDTLS_MD2_PROCESS_ALT 474 * 475 * MBEDTLS__FUNCTION_NAME__ALT: Uncomment a macro to let Mbed TLS use you 476 * alternate core implementation of symmetric crypto or hash function. Keep in 477 * mind that function prototypes should remain the same. 478 * 479 * This replaces only one function. The header file from Mbed TLS is still 480 * used, in contrast to the MBEDTLS__MODULE_NAME__ALT flags. 481 * 482 * Example: In case you uncomment MBEDTLS_SHA256_PROCESS_ALT, Mbed TLS will 483 * no longer provide the mbedtls_sha1_process() function, but it will still provide 484 * the other function (using your mbedtls_sha1_process() function) and the definition 485 * of mbedtls_sha1_context, so your implementation of mbedtls_sha1_process must be compatible 486 * with this definition. 487 * 488 * \note Because of a signature change, the core AES encryption and decryption routines are 489 * currently named mbedtls_aes_internal_encrypt and mbedtls_aes_internal_decrypt, 490 * respectively. When setting up alternative implementations, these functions should 491 * be overridden, but the wrapper functions mbedtls_aes_decrypt and mbedtls_aes_encrypt 492 * must stay untouched. 493 * 494 * \note If you use the AES_xxx_ALT macros, then it is recommended to also set 495 * MBEDTLS_AES_ROM_TABLES in order to help the linker garbage-collect the AES 496 * tables. 497 * 498 * Uncomment a macro to enable alternate implementation of the corresponding 499 * function. 500 * 501 * \warning MD2, MD4, MD5, DES and SHA-1 are considered weak and their use 502 * constitutes a security risk. If possible, we recommend avoiding 503 * dependencies on them, and considering stronger message digests 504 * and ciphers instead. 505 * 506 * \warning If both MBEDTLS_ECDSA_SIGN_ALT and MBEDTLS_ECDSA_DETERMINISTIC are 507 * enabled, then the deterministic ECDH signature functions pass the 508 * the static HMAC-DRBG as RNG to mbedtls_ecdsa_sign(). Therefore 509 * alternative implementations should use the RNG only for generating 510 * the ephemeral key and nothing else. If this is not possible, then 511 * MBEDTLS_ECDSA_DETERMINISTIC should be disabled and an alternative 512 * implementation should be provided for mbedtls_ecdsa_sign_det_ext() 513 * (and for mbedtls_ecdsa_sign_det() too if backward compatibility is 514 * desirable). 515 * 516 */ 517 //#define MBEDTLS_MD2_PROCESS_ALT 518 //#define MBEDTLS_MD4_PROCESS_ALT 519 //#define MBEDTLS_MD5_PROCESS_ALT 520 //#define MBEDTLS_RIPEMD160_PROCESS_ALT 521 //#define MBEDTLS_SHA1_PROCESS_ALT 522 //#define MBEDTLS_SHA256_PROCESS_ALT 523 //#define MBEDTLS_SHA512_PROCESS_ALT 524 //#define MBEDTLS_DES_SETKEY_ALT 525 //#define MBEDTLS_DES_CRYPT_ECB_ALT 526 //#define MBEDTLS_DES3_CRYPT_ECB_ALT 527 //#define MBEDTLS_AES_SETKEY_ENC_ALT 528 //#define MBEDTLS_AES_SETKEY_DEC_ALT 529 //#define MBEDTLS_AES_ENCRYPT_ALT 530 //#define MBEDTLS_AES_DECRYPT_ALT 531 //#define MBEDTLS_ECDH_GEN_PUBLIC_ALT 532 //#define MBEDTLS_ECDH_COMPUTE_SHARED_ALT 533 //#define MBEDTLS_ECDSA_VERIFY_ALT 534 //#define MBEDTLS_ECDSA_SIGN_ALT 535 //#define MBEDTLS_ECDSA_GENKEY_ALT 536 537 /** 538 * \def MBEDTLS_ECP_INTERNAL_ALT 539 * 540 * Expose a part of the internal interface of the Elliptic Curve Point module. 541 * 542 * MBEDTLS_ECP__FUNCTION_NAME__ALT: Uncomment a macro to let Mbed TLS use your 543 * alternative core implementation of elliptic curve arithmetic. Keep in mind 544 * that function prototypes should remain the same. 545 * 546 * This partially replaces one function. The header file from Mbed TLS is still 547 * used, in contrast to the MBEDTLS_ECP_ALT flag. The original implementation 548 * is still present and it is used for group structures not supported by the 549 * alternative. 550 * 551 * The original implementation can in addition be removed by setting the 552 * MBEDTLS_ECP_NO_FALLBACK option, in which case any function for which the 553 * corresponding MBEDTLS_ECP__FUNCTION_NAME__ALT macro is defined will not be 554 * able to fallback to curves not supported by the alternative implementation. 555 * 556 * Any of these options become available by defining MBEDTLS_ECP_INTERNAL_ALT 557 * and implementing the following functions: 558 * unsigned char mbedtls_internal_ecp_grp_capable( 559 * const mbedtls_ecp_group *grp ) 560 * int mbedtls_internal_ecp_init( const mbedtls_ecp_group *grp ) 561 * void mbedtls_internal_ecp_free( const mbedtls_ecp_group *grp ) 562 * The mbedtls_internal_ecp_grp_capable function should return 1 if the 563 * replacement functions implement arithmetic for the given group and 0 564 * otherwise. 565 * The functions mbedtls_internal_ecp_init and mbedtls_internal_ecp_free are 566 * called before and after each point operation and provide an opportunity to 567 * implement optimized set up and tear down instructions. 568 * 569 * Example: In case you set MBEDTLS_ECP_INTERNAL_ALT and 570 * MBEDTLS_ECP_DOUBLE_JAC_ALT, Mbed TLS will still provide the ecp_double_jac() 571 * function, but will use your mbedtls_internal_ecp_double_jac() if the group 572 * for the operation is supported by your implementation (i.e. your 573 * mbedtls_internal_ecp_grp_capable() function returns 1 for this group). If the 574 * group is not supported by your implementation, then the original Mbed TLS 575 * implementation of ecp_double_jac() is used instead, unless this fallback 576 * behaviour is disabled by setting MBEDTLS_ECP_NO_FALLBACK (in which case 577 * ecp_double_jac() will return MBEDTLS_ERR_ECP_FEATURE_UNAVAILABLE). 578 * 579 * The function prototypes and the definition of mbedtls_ecp_group and 580 * mbedtls_ecp_point will not change based on MBEDTLS_ECP_INTERNAL_ALT, so your 581 * implementation of mbedtls_internal_ecp__function_name__ must be compatible 582 * with their definitions. 583 * 584 * Uncomment a macro to enable alternate implementation of the corresponding 585 * function. 586 */ 587 /* Required for all the functions in this section */ 588 //#define MBEDTLS_ECP_INTERNAL_ALT 589 /* Turn off software fallback for curves not supported in hardware */ 590 //#define MBEDTLS_ECP_NO_FALLBACK 591 /* Support for Weierstrass curves with Jacobi representation */ 592 //#define MBEDTLS_ECP_RANDOMIZE_JAC_ALT 593 //#define MBEDTLS_ECP_ADD_MIXED_ALT 594 //#define MBEDTLS_ECP_DOUBLE_JAC_ALT 595 //#define MBEDTLS_ECP_NORMALIZE_JAC_MANY_ALT 596 //#define MBEDTLS_ECP_NORMALIZE_JAC_ALT 597 /* Support for curves with Montgomery arithmetic */ 598 //#define MBEDTLS_ECP_DOUBLE_ADD_MXZ_ALT 599 //#define MBEDTLS_ECP_RANDOMIZE_MXZ_ALT 600 //#define MBEDTLS_ECP_NORMALIZE_MXZ_ALT 601 602 /** 603 * \def MBEDTLS_TEST_NULL_ENTROPY 604 * 605 * Enables testing and use of Mbed TLS without any configured entropy sources. 606 * This permits use of the library on platforms before an entropy source has 607 * been integrated (see for example the MBEDTLS_ENTROPY_HARDWARE_ALT or the 608 * MBEDTLS_ENTROPY_NV_SEED switches). 609 * 610 * WARNING! This switch MUST be disabled in production builds, and is suitable 611 * only for development. 612 * Enabling the switch negates any security provided by the library. 613 * 614 * Requires MBEDTLS_ENTROPY_C, MBEDTLS_NO_DEFAULT_ENTROPY_SOURCES 615 * 616 */ 617 //#define MBEDTLS_TEST_NULL_ENTROPY 618 619 /** 620 * \def MBEDTLS_ENTROPY_HARDWARE_ALT 621 * 622 * Uncomment this macro to let Mbed TLS use your own implementation of a 623 * hardware entropy collector. 624 * 625 * Your function must be called \c mbedtls_hardware_poll(), have the same 626 * prototype as declared in entropy_poll.h, and accept NULL as first argument. 627 * 628 * Uncomment to use your own hardware entropy collector. 629 */ 630 //#define MBEDTLS_ENTROPY_HARDWARE_ALT 631 632 /** 633 * \def MBEDTLS_AES_ROM_TABLES 634 * 635 * Use precomputed AES tables stored in ROM. 636 * 637 * Uncomment this macro to use precomputed AES tables stored in ROM. 638 * Comment this macro to generate AES tables in RAM at runtime. 639 * 640 * Tradeoff: Using precomputed ROM tables reduces RAM usage by ~8kb 641 * (or ~2kb if \c MBEDTLS_AES_FEWER_TABLES is used) and reduces the 642 * initialization time before the first AES operation can be performed. 643 * It comes at the cost of additional ~8kb ROM use (resp. ~2kb if \c 644 * MBEDTLS_AES_FEWER_TABLES below is used), and potentially degraded 645 * performance if ROM access is slower than RAM access. 646 * 647 * This option is independent of \c MBEDTLS_AES_FEWER_TABLES. 648 * 649 */ 650 //#define MBEDTLS_AES_ROM_TABLES 651 652 /** 653 * \def MBEDTLS_AES_FEWER_TABLES 654 * 655 * Use less ROM/RAM for AES tables. 656 * 657 * Uncommenting this macro omits 75% of the AES tables from 658 * ROM / RAM (depending on the value of \c MBEDTLS_AES_ROM_TABLES) 659 * by computing their values on the fly during operations 660 * (the tables are entry-wise rotations of one another). 661 * 662 * Tradeoff: Uncommenting this reduces the RAM / ROM footprint 663 * by ~6kb but at the cost of more arithmetic operations during 664 * runtime. Specifically, one has to compare 4 accesses within 665 * different tables to 4 accesses with additional arithmetic 666 * operations within the same table. The performance gain/loss 667 * depends on the system and memory details. 668 * 669 * This option is independent of \c MBEDTLS_AES_ROM_TABLES. 670 * 671 */ 672 //#define MBEDTLS_AES_FEWER_TABLES 673 674 /** 675 * \def MBEDTLS_CAMELLIA_SMALL_MEMORY 676 * 677 * Use less ROM for the Camellia implementation (saves about 768 bytes). 678 * 679 * Uncomment this macro to use less memory for Camellia. 680 */ 681 //#define MBEDTLS_CAMELLIA_SMALL_MEMORY 682 683 /** 684 * \def MBEDTLS_CHECK_RETURN_WARNING 685 * 686 * If this macro is defined, emit a compile-time warning if application code 687 * calls a function without checking its return value, but the return value 688 * should generally be checked in portable applications. 689 * 690 * This is only supported on platforms where #MBEDTLS_CHECK_RETURN is 691 * implemented. Otherwise this option has no effect. 692 * 693 * Uncomment to get warnings on using fallible functions without checking 694 * their return value. 695 * 696 * \note This feature is a work in progress. 697 * Warnings will be added to more functions in the future. 698 * 699 * \note A few functions are considered critical, and ignoring the return 700 * value of these functions will trigger a warning even if this 701 * macro is not defined. To completely disable return value check 702 * warnings, define #MBEDTLS_CHECK_RETURN with an empty expansion. 703 */ 704 //#define MBEDTLS_CHECK_RETURN_WARNING 705 706 /** 707 * \def MBEDTLS_CIPHER_MODE_CBC 708 * 709 * Enable Cipher Block Chaining mode (CBC) for symmetric ciphers. 710 */ 711 #define MBEDTLS_CIPHER_MODE_CBC 712 713 /** 714 * \def MBEDTLS_CIPHER_MODE_CFB 715 * 716 * Enable Cipher Feedback mode (CFB) for symmetric ciphers. 717 */ 718 #define MBEDTLS_CIPHER_MODE_CFB 719 720 /** 721 * \def MBEDTLS_CIPHER_MODE_CTR 722 * 723 * Enable Counter Block Cipher mode (CTR) for symmetric ciphers. 724 */ 725 #define MBEDTLS_CIPHER_MODE_CTR 726 727 /** 728 * \def MBEDTLS_CIPHER_MODE_OFB 729 * 730 * Enable Output Feedback mode (OFB) for symmetric ciphers. 731 */ 732 #define MBEDTLS_CIPHER_MODE_OFB 733 734 /** 735 * \def MBEDTLS_CIPHER_MODE_XTS 736 * 737 * Enable Xor-encrypt-xor with ciphertext stealing mode (XTS) for AES. 738 */ 739 #define MBEDTLS_CIPHER_MODE_XTS 740 741 /** 742 * \def MBEDTLS_CIPHER_NULL_CIPHER 743 * 744 * Enable NULL cipher. 745 * Warning: Only do so when you know what you are doing. This allows for 746 * encryption or channels without any security! 747 * 748 * Requires MBEDTLS_ENABLE_WEAK_CIPHERSUITES as well to enable 749 * the following ciphersuites: 750 * MBEDTLS_TLS_ECDH_ECDSA_WITH_NULL_SHA 751 * MBEDTLS_TLS_ECDH_RSA_WITH_NULL_SHA 752 * MBEDTLS_TLS_ECDHE_ECDSA_WITH_NULL_SHA 753 * MBEDTLS_TLS_ECDHE_RSA_WITH_NULL_SHA 754 * MBEDTLS_TLS_ECDHE_PSK_WITH_NULL_SHA384 755 * MBEDTLS_TLS_ECDHE_PSK_WITH_NULL_SHA256 756 * MBEDTLS_TLS_ECDHE_PSK_WITH_NULL_SHA 757 * MBEDTLS_TLS_DHE_PSK_WITH_NULL_SHA384 758 * MBEDTLS_TLS_DHE_PSK_WITH_NULL_SHA256 759 * MBEDTLS_TLS_DHE_PSK_WITH_NULL_SHA 760 * MBEDTLS_TLS_RSA_WITH_NULL_SHA256 761 * MBEDTLS_TLS_RSA_WITH_NULL_SHA 762 * MBEDTLS_TLS_RSA_WITH_NULL_MD5 763 * MBEDTLS_TLS_RSA_PSK_WITH_NULL_SHA384 764 * MBEDTLS_TLS_RSA_PSK_WITH_NULL_SHA256 765 * MBEDTLS_TLS_RSA_PSK_WITH_NULL_SHA 766 * MBEDTLS_TLS_PSK_WITH_NULL_SHA384 767 * MBEDTLS_TLS_PSK_WITH_NULL_SHA256 768 * MBEDTLS_TLS_PSK_WITH_NULL_SHA 769 * 770 * Uncomment this macro to enable the NULL cipher and ciphersuites 771 */ 772 //#define MBEDTLS_CIPHER_NULL_CIPHER 773 774 /** 775 * \def MBEDTLS_CIPHER_PADDING_PKCS7 776 * 777 * MBEDTLS_CIPHER_PADDING_XXX: Uncomment or comment macros to add support for 778 * specific padding modes in the cipher layer with cipher modes that support 779 * padding (e.g. CBC) 780 * 781 * If you disable all padding modes, only full blocks can be used with CBC. 782 * 783 * Enable padding modes in the cipher layer. 784 */ 785 #define MBEDTLS_CIPHER_PADDING_PKCS7 786 #define MBEDTLS_CIPHER_PADDING_ONE_AND_ZEROS 787 #define MBEDTLS_CIPHER_PADDING_ZEROS_AND_LEN 788 #define MBEDTLS_CIPHER_PADDING_ZEROS 789 790 /** \def MBEDTLS_CTR_DRBG_USE_128_BIT_KEY 791 * 792 * Uncomment this macro to use a 128-bit key in the CTR_DRBG module. 793 * By default, CTR_DRBG uses a 256-bit key. 794 */ 795 //#define MBEDTLS_CTR_DRBG_USE_128_BIT_KEY 796 797 /** 798 * \def MBEDTLS_ENABLE_WEAK_CIPHERSUITES 799 * 800 * Enable weak ciphersuites in SSL / TLS. 801 * Warning: Only do so when you know what you are doing. This allows for 802 * channels with virtually no security at all! 803 * 804 * This enables the following ciphersuites: 805 * MBEDTLS_TLS_RSA_WITH_DES_CBC_SHA 806 * MBEDTLS_TLS_DHE_RSA_WITH_DES_CBC_SHA 807 * 808 * Uncomment this macro to enable weak ciphersuites 809 * 810 * \warning DES is considered a weak cipher and its use constitutes a 811 * security risk. We recommend considering stronger ciphers instead. 812 */ 813 //#define MBEDTLS_ENABLE_WEAK_CIPHERSUITES 814 815 /** 816 * \def MBEDTLS_REMOVE_ARC4_CIPHERSUITES 817 * 818 * Remove RC4 ciphersuites by default in SSL / TLS. 819 * This flag removes the ciphersuites based on RC4 from the default list as 820 * returned by mbedtls_ssl_list_ciphersuites(). However, it is still possible to 821 * enable (some of) them with mbedtls_ssl_conf_ciphersuites() by including them 822 * explicitly. 823 * 824 * Uncomment this macro to remove RC4 ciphersuites by default. 825 */ 826 #define MBEDTLS_REMOVE_ARC4_CIPHERSUITES 827 828 /** 829 * \def MBEDTLS_REMOVE_3DES_CIPHERSUITES 830 * 831 * Remove 3DES ciphersuites by default in SSL / TLS. 832 * This flag removes the ciphersuites based on 3DES from the default list as 833 * returned by mbedtls_ssl_list_ciphersuites(). However, it is still possible 834 * to enable (some of) them with mbedtls_ssl_conf_ciphersuites() by including 835 * them explicitly. 836 * 837 * A man-in-the-browser attacker can recover authentication tokens sent through 838 * a TLS connection using a 3DES based cipher suite (see "On the Practical 839 * (In-)Security of 64-bit Block Ciphers" by Karthikeyan Bhargavan and Gaëtan 840 * Leurent, see https://sweet32.info/SWEET32_CCS16.pdf). If this attack falls 841 * in your threat model or you are unsure, then you should keep this option 842 * enabled to remove 3DES based cipher suites. 843 * 844 * Comment this macro to keep 3DES in the default ciphersuite list. 845 */ 846 #define MBEDTLS_REMOVE_3DES_CIPHERSUITES 847 848 /** 849 * Enable the verified implementations of ECDH primitives from Project Everest 850 * (currently only Curve25519). This feature changes the layout of ECDH 851 * contexts and therefore is a compatibility break for applications that access 852 * fields of a mbedtls_ecdh_context structure directly. See also 853 * MBEDTLS_ECDH_LEGACY_CONTEXT in include/mbedtls/ecdh.h. 854 * 855 * The Everest code is provided under the Apache 2.0 license only; therefore enabling this 856 * option is not compatible with taking the library under the GPL v2.0-or-later license. 857 */ 858 //#define MBEDTLS_ECDH_VARIANT_EVEREST_ENABLED 859 860 /** 861 * \def MBEDTLS_ECP_DP_SECP192R1_ENABLED 862 * 863 * MBEDTLS_ECP_XXXX_ENABLED: Enables specific curves within the Elliptic Curve 864 * module. By default all supported curves are enabled. 865 * 866 * Comment macros to disable the curve and functions for it 867 */ 868 /* Short Weierstrass curves (supporting ECP, ECDH, ECDSA) */ 869 #define MBEDTLS_ECP_DP_SECP192R1_ENABLED 870 #define MBEDTLS_ECP_DP_SECP224R1_ENABLED 871 #define MBEDTLS_ECP_DP_SECP256R1_ENABLED 872 #define MBEDTLS_ECP_DP_SECP384R1_ENABLED 873 #define MBEDTLS_ECP_DP_SECP521R1_ENABLED 874 #define MBEDTLS_ECP_DP_SECP192K1_ENABLED 875 #define MBEDTLS_ECP_DP_SECP224K1_ENABLED 876 #define MBEDTLS_ECP_DP_SECP256K1_ENABLED 877 #define MBEDTLS_ECP_DP_BP256R1_ENABLED 878 #define MBEDTLS_ECP_DP_BP384R1_ENABLED 879 #define MBEDTLS_ECP_DP_BP512R1_ENABLED 880 /* Montgomery curves (supporting ECP) */ 881 #define MBEDTLS_ECP_DP_CURVE25519_ENABLED 882 #define MBEDTLS_ECP_DP_CURVE448_ENABLED 883 884 /** 885 * \def MBEDTLS_ECP_NIST_OPTIM 886 * 887 * Enable specific 'modulo p' routines for each NIST prime. 888 * Depending on the prime and architecture, makes operations 4 to 8 times 889 * faster on the corresponding curve. 890 * 891 * Comment this macro to disable NIST curves optimisation. 892 */ 893 #define MBEDTLS_ECP_NIST_OPTIM 894 895 /** 896 * \def MBEDTLS_ECP_NO_INTERNAL_RNG 897 * 898 * When this option is disabled, mbedtls_ecp_mul() will make use of an 899 * internal RNG when called with a NULL \c f_rng argument, in order to protect 900 * against some side-channel attacks. 901 * 902 * This protection introduces a dependency of the ECP module on one of the 903 * DRBG modules. For very constrained implementations that don't require this 904 * protection (for example, because you're only doing signature verification, 905 * so not manipulating any secret, or because local/physical side-channel 906 * attacks are outside your threat model), it might be desirable to get rid of 907 * that dependency. 908 * 909 * \warning Enabling this option makes some uses of ECP vulnerable to some 910 * side-channel attacks. Only enable it if you know that's not a problem for 911 * your use case. 912 * 913 * Uncomment this macro to disable some counter-measures in ECP. 914 */ 915 //#define MBEDTLS_ECP_NO_INTERNAL_RNG 916 917 /** 918 * \def MBEDTLS_ECP_RESTARTABLE 919 * 920 * Enable "non-blocking" ECC operations that can return early and be resumed. 921 * 922 * This allows various functions to pause by returning 923 * #MBEDTLS_ERR_ECP_IN_PROGRESS (or, for functions in the SSL module, 924 * #MBEDTLS_ERR_SSL_CRYPTO_IN_PROGRESS) and then be called later again in 925 * order to further progress and eventually complete their operation. This is 926 * controlled through mbedtls_ecp_set_max_ops() which limits the maximum 927 * number of ECC operations a function may perform before pausing; see 928 * mbedtls_ecp_set_max_ops() for more information. 929 * 930 * This is useful in non-threaded environments if you want to avoid blocking 931 * for too long on ECC (and, hence, X.509 or SSL/TLS) operations. 932 * 933 * This option: 934 * - Adds xxx_restartable() variants of existing operations in the 935 * following modules, with corresponding restart context types: 936 * - ECP (for Short Weierstrass curves only): scalar multiplication (mul), 937 * linear combination (muladd); 938 * - ECDSA: signature generation & verification; 939 * - PK: signature generation & verification; 940 * - X509: certificate chain verification. 941 * - Adds mbedtls_ecdh_enable_restart() in the ECDH module. 942 * - Changes the behaviour of TLS 1.2 clients (not servers) when using the 943 * ECDHE-ECDSA key exchange (not other key exchanges) to make all ECC 944 * computations restartable: 945 * - ECDH operations from the key exchange, only for Short Weierstrass 946 * curves; 947 * - verification of the server's key exchange signature; 948 * - verification of the server's certificate chain; 949 * - generation of the client's signature if client authentication is used, 950 * with an ECC key/certificate. 951 * 952 * \note In the cases above, the usual SSL/TLS functions, such as 953 * mbedtls_ssl_handshake(), can now return 954 * MBEDTLS_ERR_SSL_CRYPTO_IN_PROGRESS. 955 * 956 * \note This option only works with the default software implementation of 957 * elliptic curve functionality. It is incompatible with 958 * MBEDTLS_ECP_ALT, MBEDTLS_ECDH_XXX_ALT, MBEDTLS_ECDSA_XXX_ALT, 959 * MBEDTLS_ECDH_LEGACY_CONTEXT, and MBEDTLS_USE_PSA_CRYPTO. 960 * 961 * Requires: MBEDTLS_ECP_C 962 * 963 * Uncomment this macro to enable restartable ECC computations. 964 */ 965 //#define MBEDTLS_ECP_RESTARTABLE 966 967 /** 968 * \def MBEDTLS_ECDH_LEGACY_CONTEXT 969 * 970 * Use a backward compatible ECDH context. 971 * 972 * Mbed TLS supports two formats for ECDH contexts (#mbedtls_ecdh_context 973 * defined in `ecdh.h`). For most applications, the choice of format makes 974 * no difference, since all library functions can work with either format, 975 * except that the new format is incompatible with MBEDTLS_ECP_RESTARTABLE. 976 977 * The new format used when this option is disabled is smaller 978 * (56 bytes on a 32-bit platform). In future versions of the library, it 979 * will support alternative implementations of ECDH operations. 980 * The new format is incompatible with applications that access 981 * context fields directly and with restartable ECP operations. 982 * 983 * Define this macro if you enable MBEDTLS_ECP_RESTARTABLE or if you 984 * want to access ECDH context fields directly. Otherwise you should 985 * comment out this macro definition. 986 * 987 * This option has no effect if #MBEDTLS_ECDH_C is not enabled. 988 * 989 * \note This configuration option is experimental. Future versions of the 990 * library may modify the way the ECDH context layout is configured 991 * and may modify the layout of the new context type. 992 */ 993 #define MBEDTLS_ECDH_LEGACY_CONTEXT 994 995 /** 996 * \def MBEDTLS_ECDSA_DETERMINISTIC 997 * 998 * Enable deterministic ECDSA (RFC 6979). 999 * Standard ECDSA is "fragile" in the sense that lack of entropy when signing 1000 * may result in a compromise of the long-term signing key. This is avoided by 1001 * the deterministic variant. 1002 * 1003 * Requires: MBEDTLS_HMAC_DRBG_C, MBEDTLS_ECDSA_C 1004 * 1005 * Comment this macro to disable deterministic ECDSA. 1006 */ 1007 #define MBEDTLS_ECDSA_DETERMINISTIC 1008 1009 /** 1010 * \def MBEDTLS_KEY_EXCHANGE_PSK_ENABLED 1011 * 1012 * Enable the PSK based ciphersuite modes in SSL / TLS. 1013 * 1014 * This enables the following ciphersuites (if other requisites are 1015 * enabled as well): 1016 * MBEDTLS_TLS_PSK_WITH_AES_256_GCM_SHA384 1017 * MBEDTLS_TLS_PSK_WITH_AES_256_CBC_SHA384 1018 * MBEDTLS_TLS_PSK_WITH_AES_256_CBC_SHA 1019 * MBEDTLS_TLS_PSK_WITH_CAMELLIA_256_GCM_SHA384 1020 * MBEDTLS_TLS_PSK_WITH_CAMELLIA_256_CBC_SHA384 1021 * MBEDTLS_TLS_PSK_WITH_AES_128_GCM_SHA256 1022 * MBEDTLS_TLS_PSK_WITH_AES_128_CBC_SHA256 1023 * MBEDTLS_TLS_PSK_WITH_AES_128_CBC_SHA 1024 * MBEDTLS_TLS_PSK_WITH_CAMELLIA_128_GCM_SHA256 1025 * MBEDTLS_TLS_PSK_WITH_CAMELLIA_128_CBC_SHA256 1026 * MBEDTLS_TLS_PSK_WITH_3DES_EDE_CBC_SHA 1027 * MBEDTLS_TLS_PSK_WITH_RC4_128_SHA 1028 */ 1029 #define MBEDTLS_KEY_EXCHANGE_PSK_ENABLED 1030 1031 /** 1032 * \def MBEDTLS_KEY_EXCHANGE_DHE_PSK_ENABLED 1033 * 1034 * Enable the DHE-PSK based ciphersuite modes in SSL / TLS. 1035 * 1036 * Requires: MBEDTLS_DHM_C 1037 * 1038 * This enables the following ciphersuites (if other requisites are 1039 * enabled as well): 1040 * MBEDTLS_TLS_DHE_PSK_WITH_AES_256_GCM_SHA384 1041 * MBEDTLS_TLS_DHE_PSK_WITH_AES_256_CBC_SHA384 1042 * MBEDTLS_TLS_DHE_PSK_WITH_AES_256_CBC_SHA 1043 * MBEDTLS_TLS_DHE_PSK_WITH_CAMELLIA_256_GCM_SHA384 1044 * MBEDTLS_TLS_DHE_PSK_WITH_CAMELLIA_256_CBC_SHA384 1045 * MBEDTLS_TLS_DHE_PSK_WITH_AES_128_GCM_SHA256 1046 * MBEDTLS_TLS_DHE_PSK_WITH_AES_128_CBC_SHA256 1047 * MBEDTLS_TLS_DHE_PSK_WITH_AES_128_CBC_SHA 1048 * MBEDTLS_TLS_DHE_PSK_WITH_CAMELLIA_128_GCM_SHA256 1049 * MBEDTLS_TLS_DHE_PSK_WITH_CAMELLIA_128_CBC_SHA256 1050 * MBEDTLS_TLS_DHE_PSK_WITH_3DES_EDE_CBC_SHA 1051 * MBEDTLS_TLS_DHE_PSK_WITH_RC4_128_SHA 1052 * 1053 * \warning Using DHE constitutes a security risk as it 1054 * is not possible to validate custom DH parameters. 1055 * If possible, it is recommended users should consider 1056 * preferring other methods of key exchange. 1057 * See dhm.h for more details. 1058 * 1059 */ 1060 #define MBEDTLS_KEY_EXCHANGE_DHE_PSK_ENABLED 1061 1062 /** 1063 * \def MBEDTLS_KEY_EXCHANGE_ECDHE_PSK_ENABLED 1064 * 1065 * Enable the ECDHE-PSK based ciphersuite modes in SSL / TLS. 1066 * 1067 * Requires: MBEDTLS_ECDH_C 1068 * 1069 * This enables the following ciphersuites (if other requisites are 1070 * enabled as well): 1071 * MBEDTLS_TLS_ECDHE_PSK_WITH_AES_256_CBC_SHA384 1072 * MBEDTLS_TLS_ECDHE_PSK_WITH_AES_256_CBC_SHA 1073 * MBEDTLS_TLS_ECDHE_PSK_WITH_CAMELLIA_256_CBC_SHA384 1074 * MBEDTLS_TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA256 1075 * MBEDTLS_TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA 1076 * MBEDTLS_TLS_ECDHE_PSK_WITH_CAMELLIA_128_CBC_SHA256 1077 * MBEDTLS_TLS_ECDHE_PSK_WITH_3DES_EDE_CBC_SHA 1078 * MBEDTLS_TLS_ECDHE_PSK_WITH_RC4_128_SHA 1079 */ 1080 #define MBEDTLS_KEY_EXCHANGE_ECDHE_PSK_ENABLED 1081 1082 /** 1083 * \def MBEDTLS_KEY_EXCHANGE_RSA_PSK_ENABLED 1084 * 1085 * Enable the RSA-PSK based ciphersuite modes in SSL / TLS. 1086 * 1087 * Requires: MBEDTLS_RSA_C, MBEDTLS_PKCS1_V15, 1088 * MBEDTLS_X509_CRT_PARSE_C 1089 * 1090 * This enables the following ciphersuites (if other requisites are 1091 * enabled as well): 1092 * MBEDTLS_TLS_RSA_PSK_WITH_AES_256_GCM_SHA384 1093 * MBEDTLS_TLS_RSA_PSK_WITH_AES_256_CBC_SHA384 1094 * MBEDTLS_TLS_RSA_PSK_WITH_AES_256_CBC_SHA 1095 * MBEDTLS_TLS_RSA_PSK_WITH_CAMELLIA_256_GCM_SHA384 1096 * MBEDTLS_TLS_RSA_PSK_WITH_CAMELLIA_256_CBC_SHA384 1097 * MBEDTLS_TLS_RSA_PSK_WITH_AES_128_GCM_SHA256 1098 * MBEDTLS_TLS_RSA_PSK_WITH_AES_128_CBC_SHA256 1099 * MBEDTLS_TLS_RSA_PSK_WITH_AES_128_CBC_SHA 1100 * MBEDTLS_TLS_RSA_PSK_WITH_CAMELLIA_128_GCM_SHA256 1101 * MBEDTLS_TLS_RSA_PSK_WITH_CAMELLIA_128_CBC_SHA256 1102 * MBEDTLS_TLS_RSA_PSK_WITH_3DES_EDE_CBC_SHA 1103 * MBEDTLS_TLS_RSA_PSK_WITH_RC4_128_SHA 1104 */ 1105 #define MBEDTLS_KEY_EXCHANGE_RSA_PSK_ENABLED 1106 1107 /** 1108 * \def MBEDTLS_KEY_EXCHANGE_RSA_ENABLED 1109 * 1110 * Enable the RSA-only based ciphersuite modes in SSL / TLS. 1111 * 1112 * Requires: MBEDTLS_RSA_C, MBEDTLS_PKCS1_V15, 1113 * MBEDTLS_X509_CRT_PARSE_C 1114 * 1115 * This enables the following ciphersuites (if other requisites are 1116 * enabled as well): 1117 * MBEDTLS_TLS_RSA_WITH_AES_256_GCM_SHA384 1118 * MBEDTLS_TLS_RSA_WITH_AES_256_CBC_SHA256 1119 * MBEDTLS_TLS_RSA_WITH_AES_256_CBC_SHA 1120 * MBEDTLS_TLS_RSA_WITH_CAMELLIA_256_GCM_SHA384 1121 * MBEDTLS_TLS_RSA_WITH_CAMELLIA_256_CBC_SHA256 1122 * MBEDTLS_TLS_RSA_WITH_CAMELLIA_256_CBC_SHA 1123 * MBEDTLS_TLS_RSA_WITH_AES_128_GCM_SHA256 1124 * MBEDTLS_TLS_RSA_WITH_AES_128_CBC_SHA256 1125 * MBEDTLS_TLS_RSA_WITH_AES_128_CBC_SHA 1126 * MBEDTLS_TLS_RSA_WITH_CAMELLIA_128_GCM_SHA256 1127 * MBEDTLS_TLS_RSA_WITH_CAMELLIA_128_CBC_SHA256 1128 * MBEDTLS_TLS_RSA_WITH_CAMELLIA_128_CBC_SHA 1129 * MBEDTLS_TLS_RSA_WITH_3DES_EDE_CBC_SHA 1130 * MBEDTLS_TLS_RSA_WITH_RC4_128_SHA 1131 * MBEDTLS_TLS_RSA_WITH_RC4_128_MD5 1132 */ 1133 #define MBEDTLS_KEY_EXCHANGE_RSA_ENABLED 1134 1135 /** 1136 * \def MBEDTLS_KEY_EXCHANGE_DHE_RSA_ENABLED 1137 * 1138 * Enable the DHE-RSA based ciphersuite modes in SSL / TLS. 1139 * 1140 * Requires: MBEDTLS_DHM_C, MBEDTLS_RSA_C, MBEDTLS_PKCS1_V15, 1141 * MBEDTLS_X509_CRT_PARSE_C 1142 * 1143 * This enables the following ciphersuites (if other requisites are 1144 * enabled as well): 1145 * MBEDTLS_TLS_DHE_RSA_WITH_AES_256_GCM_SHA384 1146 * MBEDTLS_TLS_DHE_RSA_WITH_AES_256_CBC_SHA256 1147 * MBEDTLS_TLS_DHE_RSA_WITH_AES_256_CBC_SHA 1148 * MBEDTLS_TLS_DHE_RSA_WITH_CAMELLIA_256_GCM_SHA384 1149 * MBEDTLS_TLS_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA256 1150 * MBEDTLS_TLS_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA 1151 * MBEDTLS_TLS_DHE_RSA_WITH_AES_128_GCM_SHA256 1152 * MBEDTLS_TLS_DHE_RSA_WITH_AES_128_CBC_SHA256 1153 * MBEDTLS_TLS_DHE_RSA_WITH_AES_128_CBC_SHA 1154 * MBEDTLS_TLS_DHE_RSA_WITH_CAMELLIA_128_GCM_SHA256 1155 * MBEDTLS_TLS_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA256 1156 * MBEDTLS_TLS_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA 1157 * MBEDTLS_TLS_DHE_RSA_WITH_3DES_EDE_CBC_SHA 1158 * 1159 * \warning Using DHE constitutes a security risk as it 1160 * is not possible to validate custom DH parameters. 1161 * If possible, it is recommended users should consider 1162 * preferring other methods of key exchange. 1163 * See dhm.h for more details. 1164 * 1165 */ 1166 #define MBEDTLS_KEY_EXCHANGE_DHE_RSA_ENABLED 1167 1168 /** 1169 * \def MBEDTLS_KEY_EXCHANGE_ECDHE_RSA_ENABLED 1170 * 1171 * Enable the ECDHE-RSA based ciphersuite modes in SSL / TLS. 1172 * 1173 * Requires: MBEDTLS_ECDH_C, MBEDTLS_RSA_C, MBEDTLS_PKCS1_V15, 1174 * MBEDTLS_X509_CRT_PARSE_C 1175 * 1176 * This enables the following ciphersuites (if other requisites are 1177 * enabled as well): 1178 * MBEDTLS_TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 1179 * MBEDTLS_TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384 1180 * MBEDTLS_TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA 1181 * MBEDTLS_TLS_ECDHE_RSA_WITH_CAMELLIA_256_GCM_SHA384 1182 * MBEDTLS_TLS_ECDHE_RSA_WITH_CAMELLIA_256_CBC_SHA384 1183 * MBEDTLS_TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256 1184 * MBEDTLS_TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256 1185 * MBEDTLS_TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA 1186 * MBEDTLS_TLS_ECDHE_RSA_WITH_CAMELLIA_128_GCM_SHA256 1187 * MBEDTLS_TLS_ECDHE_RSA_WITH_CAMELLIA_128_CBC_SHA256 1188 * MBEDTLS_TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA 1189 * MBEDTLS_TLS_ECDHE_RSA_WITH_RC4_128_SHA 1190 */ 1191 #define MBEDTLS_KEY_EXCHANGE_ECDHE_RSA_ENABLED 1192 1193 /** 1194 * \def MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA_ENABLED 1195 * 1196 * Enable the ECDHE-ECDSA based ciphersuite modes in SSL / TLS. 1197 * 1198 * Requires: MBEDTLS_ECDH_C, MBEDTLS_ECDSA_C, MBEDTLS_X509_CRT_PARSE_C, 1199 * 1200 * This enables the following ciphersuites (if other requisites are 1201 * enabled as well): 1202 * MBEDTLS_TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384 1203 * MBEDTLS_TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384 1204 * MBEDTLS_TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA 1205 * MBEDTLS_TLS_ECDHE_ECDSA_WITH_CAMELLIA_256_GCM_SHA384 1206 * MBEDTLS_TLS_ECDHE_ECDSA_WITH_CAMELLIA_256_CBC_SHA384 1207 * MBEDTLS_TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256 1208 * MBEDTLS_TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256 1209 * MBEDTLS_TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA 1210 * MBEDTLS_TLS_ECDHE_ECDSA_WITH_CAMELLIA_128_GCM_SHA256 1211 * MBEDTLS_TLS_ECDHE_ECDSA_WITH_CAMELLIA_128_CBC_SHA256 1212 * MBEDTLS_TLS_ECDHE_ECDSA_WITH_3DES_EDE_CBC_SHA 1213 * MBEDTLS_TLS_ECDHE_ECDSA_WITH_RC4_128_SHA 1214 */ 1215 #define MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA_ENABLED 1216 1217 /** 1218 * \def MBEDTLS_KEY_EXCHANGE_ECDH_ECDSA_ENABLED 1219 * 1220 * Enable the ECDH-ECDSA based ciphersuite modes in SSL / TLS. 1221 * 1222 * Requires: MBEDTLS_ECDH_C, MBEDTLS_ECDSA_C, MBEDTLS_X509_CRT_PARSE_C 1223 * 1224 * This enables the following ciphersuites (if other requisites are 1225 * enabled as well): 1226 * MBEDTLS_TLS_ECDH_ECDSA_WITH_RC4_128_SHA 1227 * MBEDTLS_TLS_ECDH_ECDSA_WITH_3DES_EDE_CBC_SHA 1228 * MBEDTLS_TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA 1229 * MBEDTLS_TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA 1230 * MBEDTLS_TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA256 1231 * MBEDTLS_TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA384 1232 * MBEDTLS_TLS_ECDH_ECDSA_WITH_AES_128_GCM_SHA256 1233 * MBEDTLS_TLS_ECDH_ECDSA_WITH_AES_256_GCM_SHA384 1234 * MBEDTLS_TLS_ECDH_ECDSA_WITH_CAMELLIA_128_CBC_SHA256 1235 * MBEDTLS_TLS_ECDH_ECDSA_WITH_CAMELLIA_256_CBC_SHA384 1236 * MBEDTLS_TLS_ECDH_ECDSA_WITH_CAMELLIA_128_GCM_SHA256 1237 * MBEDTLS_TLS_ECDH_ECDSA_WITH_CAMELLIA_256_GCM_SHA384 1238 */ 1239 #define MBEDTLS_KEY_EXCHANGE_ECDH_ECDSA_ENABLED 1240 1241 /** 1242 * \def MBEDTLS_KEY_EXCHANGE_ECDH_RSA_ENABLED 1243 * 1244 * Enable the ECDH-RSA based ciphersuite modes in SSL / TLS. 1245 * 1246 * Requires: MBEDTLS_ECDH_C, MBEDTLS_RSA_C, MBEDTLS_X509_CRT_PARSE_C 1247 * 1248 * This enables the following ciphersuites (if other requisites are 1249 * enabled as well): 1250 * MBEDTLS_TLS_ECDH_RSA_WITH_RC4_128_SHA 1251 * MBEDTLS_TLS_ECDH_RSA_WITH_3DES_EDE_CBC_SHA 1252 * MBEDTLS_TLS_ECDH_RSA_WITH_AES_128_CBC_SHA 1253 * MBEDTLS_TLS_ECDH_RSA_WITH_AES_256_CBC_SHA 1254 * MBEDTLS_TLS_ECDH_RSA_WITH_AES_128_CBC_SHA256 1255 * MBEDTLS_TLS_ECDH_RSA_WITH_AES_256_CBC_SHA384 1256 * MBEDTLS_TLS_ECDH_RSA_WITH_AES_128_GCM_SHA256 1257 * MBEDTLS_TLS_ECDH_RSA_WITH_AES_256_GCM_SHA384 1258 * MBEDTLS_TLS_ECDH_RSA_WITH_CAMELLIA_128_CBC_SHA256 1259 * MBEDTLS_TLS_ECDH_RSA_WITH_CAMELLIA_256_CBC_SHA384 1260 * MBEDTLS_TLS_ECDH_RSA_WITH_CAMELLIA_128_GCM_SHA256 1261 * MBEDTLS_TLS_ECDH_RSA_WITH_CAMELLIA_256_GCM_SHA384 1262 */ 1263 #define MBEDTLS_KEY_EXCHANGE_ECDH_RSA_ENABLED 1264 1265 /** 1266 * \def MBEDTLS_KEY_EXCHANGE_ECJPAKE_ENABLED 1267 * 1268 * Enable the ECJPAKE based ciphersuite modes in SSL / TLS. 1269 * 1270 * \warning This is currently experimental. EC J-PAKE support is based on the 1271 * Thread v1.0.0 specification; incompatible changes to the specification 1272 * might still happen. For this reason, this is disabled by default. 1273 * 1274 * Requires: MBEDTLS_ECJPAKE_C 1275 * MBEDTLS_SHA256_C 1276 * MBEDTLS_ECP_DP_SECP256R1_ENABLED 1277 * 1278 * This enables the following ciphersuites (if other requisites are 1279 * enabled as well): 1280 * MBEDTLS_TLS_ECJPAKE_WITH_AES_128_CCM_8 1281 */ 1282 //#define MBEDTLS_KEY_EXCHANGE_ECJPAKE_ENABLED 1283 1284 /** 1285 * \def MBEDTLS_PK_PARSE_EC_EXTENDED 1286 * 1287 * Enhance support for reading EC keys using variants of SEC1 not allowed by 1288 * RFC 5915 and RFC 5480. 1289 * 1290 * Currently this means parsing the SpecifiedECDomain choice of EC 1291 * parameters (only known groups are supported, not arbitrary domains, to 1292 * avoid validation issues). 1293 * 1294 * Disable if you only need to support RFC 5915 + 5480 key formats. 1295 */ 1296 #define MBEDTLS_PK_PARSE_EC_EXTENDED 1297 1298 /** 1299 * \def MBEDTLS_ERROR_STRERROR_DUMMY 1300 * 1301 * Enable a dummy error function to make use of mbedtls_strerror() in 1302 * third party libraries easier when MBEDTLS_ERROR_C is disabled 1303 * (no effect when MBEDTLS_ERROR_C is enabled). 1304 * 1305 * You can safely disable this if MBEDTLS_ERROR_C is enabled, or if you're 1306 * not using mbedtls_strerror() or error_strerror() in your application. 1307 * 1308 * Disable if you run into name conflicts and want to really remove the 1309 * mbedtls_strerror() 1310 */ 1311 #define MBEDTLS_ERROR_STRERROR_DUMMY 1312 1313 /** 1314 * \def MBEDTLS_GENPRIME 1315 * 1316 * Enable the prime-number generation code. 1317 * 1318 * Requires: MBEDTLS_BIGNUM_C 1319 */ 1320 #define MBEDTLS_GENPRIME 1321 1322 /** 1323 * \def MBEDTLS_FS_IO 1324 * 1325 * Enable functions that use the filesystem. 1326 */ 1327 #define MBEDTLS_FS_IO 1328 1329 /** 1330 * \def MBEDTLS_NO_DEFAULT_ENTROPY_SOURCES 1331 * 1332 * Do not add default entropy sources. These are the platform specific, 1333 * mbedtls_timing_hardclock and HAVEGE based poll functions. 1334 * 1335 * This is useful to have more control over the added entropy sources in an 1336 * application. 1337 * 1338 * Uncomment this macro to prevent loading of default entropy functions. 1339 */ 1340 //#define MBEDTLS_NO_DEFAULT_ENTROPY_SOURCES 1341 1342 /** 1343 * \def MBEDTLS_NO_PLATFORM_ENTROPY 1344 * 1345 * Do not use built-in platform entropy functions. 1346 * This is useful if your platform does not support 1347 * standards like the /dev/urandom or Windows CryptoAPI. 1348 * 1349 * Uncomment this macro to disable the built-in platform entropy functions. 1350 */ 1351 //#define MBEDTLS_NO_PLATFORM_ENTROPY 1352 1353 /** 1354 * \def MBEDTLS_ENTROPY_FORCE_SHA256 1355 * 1356 * Force the entropy accumulator to use a SHA-256 accumulator instead of the 1357 * default SHA-512 based one (if both are available). 1358 * 1359 * Requires: MBEDTLS_SHA256_C 1360 * 1361 * On 32-bit systems SHA-256 can be much faster than SHA-512. Use this option 1362 * if you have performance concerns. 1363 * 1364 * This option is only useful if both MBEDTLS_SHA256_C and 1365 * MBEDTLS_SHA512_C are defined. Otherwise the available hash module is used. 1366 */ 1367 //#define MBEDTLS_ENTROPY_FORCE_SHA256 1368 1369 /** 1370 * \def MBEDTLS_ENTROPY_NV_SEED 1371 * 1372 * Enable the non-volatile (NV) seed file-based entropy source. 1373 * (Also enables the NV seed read/write functions in the platform layer) 1374 * 1375 * This is crucial (if not required) on systems that do not have a 1376 * cryptographic entropy source (in hardware or kernel) available. 1377 * 1378 * Requires: MBEDTLS_ENTROPY_C, MBEDTLS_PLATFORM_C 1379 * 1380 * \note The read/write functions that are used by the entropy source are 1381 * determined in the platform layer, and can be modified at runtime and/or 1382 * compile-time depending on the flags (MBEDTLS_PLATFORM_NV_SEED_*) used. 1383 * 1384 * \note If you use the default implementation functions that read a seedfile 1385 * with regular fopen(), please make sure you make a seedfile with the 1386 * proper name (defined in MBEDTLS_PLATFORM_STD_NV_SEED_FILE) and at 1387 * least MBEDTLS_ENTROPY_BLOCK_SIZE bytes in size that can be read from 1388 * and written to or you will get an entropy source error! The default 1389 * implementation will only use the first MBEDTLS_ENTROPY_BLOCK_SIZE 1390 * bytes from the file. 1391 * 1392 * \note The entropy collector will write to the seed file before entropy is 1393 * given to an external source, to update it. 1394 */ 1395 //#define MBEDTLS_ENTROPY_NV_SEED 1396 1397 /* MBEDTLS_PSA_CRYPTO_KEY_ID_ENCODES_OWNER 1398 * 1399 * Enable key identifiers that encode a key owner identifier. 1400 * 1401 * The owner of a key is identified by a value of type ::mbedtls_key_owner_id_t 1402 * which is currently hard-coded to be int32_t. 1403 * 1404 * Note that this option is meant for internal use only and may be removed 1405 * without notice. It is incompatible with MBEDTLS_USE_PSA_CRYPTO. 1406 */ 1407 //#define MBEDTLS_PSA_CRYPTO_KEY_ID_ENCODES_OWNER 1408 1409 /** 1410 * \def MBEDTLS_MEMORY_DEBUG 1411 * 1412 * Enable debugging of buffer allocator memory issues. Automatically prints 1413 * (to stderr) all (fatal) messages on memory allocation issues. Enables 1414 * function for 'debug output' of allocated memory. 1415 * 1416 * Requires: MBEDTLS_MEMORY_BUFFER_ALLOC_C 1417 * 1418 * Uncomment this macro to let the buffer allocator print out error messages. 1419 */ 1420 //#define MBEDTLS_MEMORY_DEBUG 1421 1422 /** 1423 * \def MBEDTLS_MEMORY_BACKTRACE 1424 * 1425 * Include backtrace information with each allocated block. 1426 * 1427 * Requires: MBEDTLS_MEMORY_BUFFER_ALLOC_C 1428 * GLIBC-compatible backtrace() and backtrace_symbols() support 1429 * 1430 * Uncomment this macro to include backtrace information 1431 */ 1432 //#define MBEDTLS_MEMORY_BACKTRACE 1433 1434 /** 1435 * \def MBEDTLS_PK_RSA_ALT_SUPPORT 1436 * 1437 * Support external private RSA keys (eg from a HSM) in the PK layer. 1438 * 1439 * Comment this macro to disable support for external private RSA keys. 1440 */ 1441 #define MBEDTLS_PK_RSA_ALT_SUPPORT 1442 1443 /** 1444 * \def MBEDTLS_PKCS1_V15 1445 * 1446 * Enable support for PKCS#1 v1.5 encoding. 1447 * 1448 * Requires: MBEDTLS_RSA_C 1449 * 1450 * This enables support for PKCS#1 v1.5 operations. 1451 */ 1452 #define MBEDTLS_PKCS1_V15 1453 1454 /** 1455 * \def MBEDTLS_PKCS1_V21 1456 * 1457 * Enable support for PKCS#1 v2.1 encoding. 1458 * 1459 * Requires: MBEDTLS_MD_C, MBEDTLS_RSA_C 1460 * 1461 * This enables support for RSAES-OAEP and RSASSA-PSS operations. 1462 */ 1463 #define MBEDTLS_PKCS1_V21 1464 1465 /** \def MBEDTLS_PSA_CRYPTO_BUILTIN_KEYS 1466 * 1467 * Enable support for platform built-in keys. If you enable this feature, 1468 * you must implement the function mbedtls_psa_platform_get_builtin_key(). 1469 * See the documentation of that function for more information. 1470 * 1471 * Built-in keys are typically derived from a hardware unique key or 1472 * stored in a secure element. 1473 * 1474 * Requires: MBEDTLS_PSA_CRYPTO_C. 1475 * 1476 * \warning This interface is experimental and may change or be removed 1477 * without notice. 1478 */ 1479 //#define MBEDTLS_PSA_CRYPTO_BUILTIN_KEYS 1480 1481 /** \def MBEDTLS_PSA_CRYPTO_CLIENT 1482 * 1483 * Enable support for PSA crypto client. 1484 * 1485 * \note This option allows to include the code necessary for a PSA 1486 * crypto client when the PSA crypto implementation is not included in 1487 * the library (MBEDTLS_PSA_CRYPTO_C disabled). The code included is the 1488 * code to set and get PSA key attributes. 1489 * The development of PSA drivers partially relying on the library to 1490 * fulfill the hardware gaps is another possible usage of this option. 1491 * 1492 * \warning This interface is experimental and may change or be removed 1493 * without notice. 1494 */ 1495 //#define MBEDTLS_PSA_CRYPTO_CLIENT 1496 1497 /** \def MBEDTLS_PSA_CRYPTO_DRIVERS 1498 * 1499 * Enable support for the experimental PSA crypto driver interface. 1500 * 1501 * Requires: MBEDTLS_PSA_CRYPTO_C 1502 * 1503 * \warning This interface is experimental and may change or be removed 1504 * without notice. 1505 */ 1506 //#define MBEDTLS_PSA_CRYPTO_DRIVERS 1507 1508 /** \def MBEDTLS_PSA_CRYPTO_EXTERNAL_RNG 1509 * 1510 * Make the PSA Crypto module use an external random generator provided 1511 * by a driver, instead of Mbed TLS's entropy and DRBG modules. 1512 * 1513 * \note This random generator must deliver random numbers with cryptographic 1514 * quality and high performance. It must supply unpredictable numbers 1515 * with a uniform distribution. The implementation of this function 1516 * is responsible for ensuring that the random generator is seeded 1517 * with sufficient entropy. If you have a hardware TRNG which is slow 1518 * or delivers non-uniform output, declare it as an entropy source 1519 * with mbedtls_entropy_add_source() instead of enabling this option. 1520 * 1521 * If you enable this option, you must configure the type 1522 * ::mbedtls_psa_external_random_context_t in psa/crypto_platform.h 1523 * and define a function called mbedtls_psa_external_get_random() 1524 * with the following prototype: 1525 * ``` 1526 * psa_status_t mbedtls_psa_external_get_random( 1527 * mbedtls_psa_external_random_context_t *context, 1528 * uint8_t *output, size_t output_size, size_t *output_length); 1529 * ); 1530 * ``` 1531 * The \c context value is initialized to 0 before the first call. 1532 * The function must fill the \c output buffer with \c output_size bytes 1533 * of random data and set \c *output_length to \c output_size. 1534 * 1535 * Requires: MBEDTLS_PSA_CRYPTO_C 1536 * 1537 * \warning If you enable this option, code that uses the PSA cryptography 1538 * interface will not use any of the entropy sources set up for 1539 * the entropy module, nor the NV seed that MBEDTLS_ENTROPY_NV_SEED 1540 * enables. 1541 * 1542 * \note This option is experimental and may be removed without notice. 1543 */ 1544 //#define MBEDTLS_PSA_CRYPTO_EXTERNAL_RNG 1545 1546 /** 1547 * \def MBEDTLS_PSA_CRYPTO_SPM 1548 * 1549 * When MBEDTLS_PSA_CRYPTO_SPM is defined, the code is built for SPM (Secure 1550 * Partition Manager) integration which separates the code into two parts: a 1551 * NSPE (Non-Secure Process Environment) and an SPE (Secure Process 1552 * Environment). 1553 * 1554 * Module: library/psa_crypto.c 1555 * Requires: MBEDTLS_PSA_CRYPTO_C 1556 * 1557 */ 1558 //#define MBEDTLS_PSA_CRYPTO_SPM 1559 1560 /** 1561 * \def MBEDTLS_PSA_INJECT_ENTROPY 1562 * 1563 * Enable support for entropy injection at first boot. This feature is 1564 * required on systems that do not have a built-in entropy source (TRNG). 1565 * This feature is currently not supported on systems that have a built-in 1566 * entropy source. 1567 * 1568 * Requires: MBEDTLS_PSA_CRYPTO_STORAGE_C, MBEDTLS_ENTROPY_NV_SEED 1569 * 1570 */ 1571 //#define MBEDTLS_PSA_INJECT_ENTROPY 1572 1573 /** 1574 * \def MBEDTLS_RSA_NO_CRT 1575 * 1576 * Do not use the Chinese Remainder Theorem 1577 * for the RSA private operation. 1578 * 1579 * Uncomment this macro to disable the use of CRT in RSA. 1580 * 1581 */ 1582 //#define MBEDTLS_RSA_NO_CRT 1583 1584 /** 1585 * \def MBEDTLS_SELF_TEST 1586 * 1587 * Enable the checkup functions (*_self_test). 1588 */ 1589 #define MBEDTLS_SELF_TEST 1590 1591 /** 1592 * \def MBEDTLS_SHA256_SMALLER 1593 * 1594 * Enable an implementation of SHA-256 that has lower ROM footprint but also 1595 * lower performance. 1596 * 1597 * The default implementation is meant to be a reasonable compromise between 1598 * performance and size. This version optimizes more aggressively for size at 1599 * the expense of performance. Eg on Cortex-M4 it reduces the size of 1600 * mbedtls_sha256_process() from ~2KB to ~0.5KB for a performance hit of about 1601 * 30%. 1602 * 1603 * Uncomment to enable the smaller implementation of SHA256. 1604 */ 1605 //#define MBEDTLS_SHA256_SMALLER 1606 1607 /** 1608 * \def MBEDTLS_SHA512_SMALLER 1609 * 1610 * Enable an implementation of SHA-512 that has lower ROM footprint but also 1611 * lower performance. 1612 * 1613 * Uncomment to enable the smaller implementation of SHA512. 1614 */ 1615 //#define MBEDTLS_SHA512_SMALLER 1616 1617 /** 1618 * \def MBEDTLS_SHA512_NO_SHA384 1619 * 1620 * Disable the SHA-384 option of the SHA-512 module. Use this to save some 1621 * code size on devices that don't use SHA-384. 1622 * 1623 * Requires: MBEDTLS_SHA512_C 1624 * 1625 * Uncomment to disable SHA-384 1626 */ 1627 //#define MBEDTLS_SHA512_NO_SHA384 1628 1629 /** 1630 * \def MBEDTLS_SSL_ALL_ALERT_MESSAGES 1631 * 1632 * Enable sending of alert messages in case of encountered errors as per RFC. 1633 * If you choose not to send the alert messages, Mbed TLS can still communicate 1634 * with other servers, only debugging of failures is harder. 1635 * 1636 * The advantage of not sending alert messages, is that no information is given 1637 * about reasons for failures thus preventing adversaries of gaining intel. 1638 * 1639 * Enable sending of all alert messages 1640 */ 1641 #define MBEDTLS_SSL_ALL_ALERT_MESSAGES 1642 1643 /** 1644 * \def MBEDTLS_SSL_RECORD_CHECKING 1645 * 1646 * Enable the function mbedtls_ssl_check_record() which can be used to check 1647 * the validity and authenticity of an incoming record, to verify that it has 1648 * not been seen before. These checks are performed without modifying the 1649 * externally visible state of the SSL context. 1650 * 1651 * See mbedtls_ssl_check_record() for more information. 1652 * 1653 * Uncomment to enable support for record checking. 1654 */ 1655 #define MBEDTLS_SSL_RECORD_CHECKING 1656 1657 /** 1658 * \def MBEDTLS_SSL_DTLS_CONNECTION_ID 1659 * 1660 * Enable support for the DTLS Connection ID extension 1661 * (version draft-ietf-tls-dtls-connection-id-05, 1662 * https://tools.ietf.org/html/draft-ietf-tls-dtls-connection-id-05) 1663 * which allows to identify DTLS connections across changes 1664 * in the underlying transport. 1665 * 1666 * Setting this option enables the SSL APIs `mbedtls_ssl_set_cid()`, 1667 * `mbedtls_ssl_get_peer_cid()` and `mbedtls_ssl_conf_cid()`. 1668 * See the corresponding documentation for more information. 1669 * 1670 * \warning The Connection ID extension is still in draft state. 1671 * We make no stability promises for the availability 1672 * or the shape of the API controlled by this option. 1673 * 1674 * The maximum lengths of outgoing and incoming CIDs can be configured 1675 * through the options 1676 * - MBEDTLS_SSL_CID_OUT_LEN_MAX 1677 * - MBEDTLS_SSL_CID_IN_LEN_MAX. 1678 * 1679 * Requires: MBEDTLS_SSL_PROTO_DTLS 1680 * 1681 * Uncomment to enable the Connection ID extension. 1682 */ 1683 //#define MBEDTLS_SSL_DTLS_CONNECTION_ID 1684 1685 /** 1686 * \def MBEDTLS_SSL_ASYNC_PRIVATE 1687 * 1688 * Enable asynchronous external private key operations in SSL. This allows 1689 * you to configure an SSL connection to call an external cryptographic 1690 * module to perform private key operations instead of performing the 1691 * operation inside the library. 1692 * 1693 */ 1694 //#define MBEDTLS_SSL_ASYNC_PRIVATE 1695 1696 /** 1697 * \def MBEDTLS_SSL_CONTEXT_SERIALIZATION 1698 * 1699 * Enable serialization of the TLS context structures, through use of the 1700 * functions mbedtls_ssl_context_save() and mbedtls_ssl_context_load(). 1701 * 1702 * This pair of functions allows one side of a connection to serialize the 1703 * context associated with the connection, then free or re-use that context 1704 * while the serialized state is persisted elsewhere, and finally deserialize 1705 * that state to a live context for resuming read/write operations on the 1706 * connection. From a protocol perspective, the state of the connection is 1707 * unaffected, in particular this is entirely transparent to the peer. 1708 * 1709 * Note: this is distinct from TLS session resumption, which is part of the 1710 * protocol and fully visible by the peer. TLS session resumption enables 1711 * establishing new connections associated to a saved session with shorter, 1712 * lighter handshakes, while context serialization is a local optimization in 1713 * handling a single, potentially long-lived connection. 1714 * 1715 * Enabling these APIs makes some SSL structures larger, as 64 extra bytes are 1716 * saved after the handshake to allow for more efficient serialization, so if 1717 * you don't need this feature you'll save RAM by disabling it. 1718 * 1719 * Requires: MBEDTLS_GCM_C or MBEDTLS_CCM_C or MBEDTLS_CHACHAPOLY_C 1720 * 1721 * Comment to disable the context serialization APIs. 1722 */ 1723 #define MBEDTLS_SSL_CONTEXT_SERIALIZATION 1724 1725 /** 1726 * \def MBEDTLS_SSL_DEBUG_ALL 1727 * 1728 * Enable the debug messages in SSL module for all issues. 1729 * Debug messages have been disabled in some places to prevent timing 1730 * attacks due to (unbalanced) debugging function calls. 1731 * 1732 * If you need all error reporting you should enable this during debugging, 1733 * but remove this for production servers that should log as well. 1734 * 1735 * Uncomment this macro to report all debug messages on errors introducing 1736 * a timing side-channel. 1737 * 1738 */ 1739 //#define MBEDTLS_SSL_DEBUG_ALL 1740 1741 /** \def MBEDTLS_SSL_ENCRYPT_THEN_MAC 1742 * 1743 * Enable support for Encrypt-then-MAC, RFC 7366. 1744 * 1745 * This allows peers that both support it to use a more robust protection for 1746 * ciphersuites using CBC, providing deep resistance against timing attacks 1747 * on the padding or underlying cipher. 1748 * 1749 * This only affects CBC ciphersuites, and is useless if none is defined. 1750 * 1751 * Requires: MBEDTLS_SSL_PROTO_TLS1 or 1752 * MBEDTLS_SSL_PROTO_TLS1_1 or 1753 * MBEDTLS_SSL_PROTO_TLS1_2 1754 * 1755 * Comment this macro to disable support for Encrypt-then-MAC 1756 */ 1757 #define MBEDTLS_SSL_ENCRYPT_THEN_MAC 1758 1759 /** \def MBEDTLS_SSL_EXTENDED_MASTER_SECRET 1760 * 1761 * Enable support for RFC 7627: Session Hash and Extended Master Secret 1762 * Extension. 1763 * 1764 * This was introduced as "the proper fix" to the Triple Handshake family of 1765 * attacks, but it is recommended to always use it (even if you disable 1766 * renegotiation), since it actually fixes a more fundamental issue in the 1767 * original SSL/TLS design, and has implications beyond Triple Handshake. 1768 * 1769 * Requires: MBEDTLS_SSL_PROTO_TLS1 or 1770 * MBEDTLS_SSL_PROTO_TLS1_1 or 1771 * MBEDTLS_SSL_PROTO_TLS1_2 1772 * 1773 * Comment this macro to disable support for Extended Master Secret. 1774 */ 1775 #define MBEDTLS_SSL_EXTENDED_MASTER_SECRET 1776 1777 /** 1778 * \def MBEDTLS_SSL_FALLBACK_SCSV 1779 * 1780 * Enable support for RFC 7507: Fallback Signaling Cipher Suite Value (SCSV) 1781 * for Preventing Protocol Downgrade Attacks. 1782 * 1783 * For servers, it is recommended to always enable this, unless you support 1784 * only one version of TLS, or know for sure that none of your clients 1785 * implements a fallback strategy. 1786 * 1787 * For clients, you only need this if you're using a fallback strategy, which 1788 * is not recommended in the first place, unless you absolutely need it to 1789 * interoperate with buggy (version-intolerant) servers. 1790 * 1791 * Comment this macro to disable support for FALLBACK_SCSV 1792 */ 1793 #define MBEDTLS_SSL_FALLBACK_SCSV 1794 1795 /** 1796 * \def MBEDTLS_SSL_KEEP_PEER_CERTIFICATE 1797 * 1798 * This option controls the availability of the API mbedtls_ssl_get_peer_cert() 1799 * giving access to the peer's certificate after completion of the handshake. 1800 * 1801 * Unless you need mbedtls_ssl_peer_cert() in your application, it is 1802 * recommended to disable this option for reduced RAM usage. 1803 * 1804 * \note If this option is disabled, mbedtls_ssl_get_peer_cert() is still 1805 * defined, but always returns \c NULL. 1806 * 1807 * \note This option has no influence on the protection against the 1808 * triple handshake attack. Even if it is disabled, Mbed TLS will 1809 * still ensure that certificates do not change during renegotiation, 1810 * for example by keeping a hash of the peer's certificate. 1811 * 1812 * Comment this macro to disable storing the peer's certificate 1813 * after the handshake. 1814 */ 1815 #define MBEDTLS_SSL_KEEP_PEER_CERTIFICATE 1816 1817 /** 1818 * \def MBEDTLS_SSL_HW_RECORD_ACCEL 1819 * 1820 * Enable hooking functions in SSL module for hardware acceleration of 1821 * individual records. 1822 * 1823 * \deprecated This option is deprecated and will be removed in a future 1824 * version of Mbed TLS. 1825 * 1826 * Uncomment this macro to enable hooking functions. 1827 */ 1828 //#define MBEDTLS_SSL_HW_RECORD_ACCEL 1829 1830 /** 1831 * \def MBEDTLS_SSL_CBC_RECORD_SPLITTING 1832 * 1833 * Enable 1/n-1 record splitting for CBC mode in SSLv3 and TLS 1.0. 1834 * 1835 * This is a countermeasure to the BEAST attack, which also minimizes the risk 1836 * of interoperability issues compared to sending 0-length records. 1837 * 1838 * Comment this macro to disable 1/n-1 record splitting. 1839 */ 1840 #define MBEDTLS_SSL_CBC_RECORD_SPLITTING 1841 1842 /** 1843 * \def MBEDTLS_SSL_RENEGOTIATION 1844 * 1845 * Enable support for TLS renegotiation. 1846 * 1847 * The two main uses of renegotiation are (1) refresh keys on long-lived 1848 * connections and (2) client authentication after the initial handshake. 1849 * If you don't need renegotiation, it's probably better to disable it, since 1850 * it has been associated with security issues in the past and is easy to 1851 * misuse/misunderstand. 1852 * 1853 * Comment this to disable support for renegotiation. 1854 * 1855 * \note Even if this option is disabled, both client and server are aware 1856 * of the Renegotiation Indication Extension (RFC 5746) used to 1857 * prevent the SSL renegotiation attack (see RFC 5746 Sect. 1). 1858 * (See \c mbedtls_ssl_conf_legacy_renegotiation for the 1859 * configuration of this extension). 1860 * 1861 */ 1862 #define MBEDTLS_SSL_RENEGOTIATION 1863 1864 /** 1865 * \def MBEDTLS_SSL_SRV_SUPPORT_SSLV2_CLIENT_HELLO 1866 * 1867 * Enable support for receiving and parsing SSLv2 Client Hello messages for the 1868 * SSL Server module (MBEDTLS_SSL_SRV_C). 1869 * 1870 * \deprecated This option is deprecated and will be removed in a future 1871 * version of Mbed TLS. 1872 * 1873 * Uncomment this macro to enable support for SSLv2 Client Hello messages. 1874 */ 1875 //#define MBEDTLS_SSL_SRV_SUPPORT_SSLV2_CLIENT_HELLO 1876 1877 /** 1878 * \def MBEDTLS_SSL_SRV_RESPECT_CLIENT_PREFERENCE 1879 * 1880 * Pick the ciphersuite according to the client's preferences rather than ours 1881 * in the SSL Server module (MBEDTLS_SSL_SRV_C). 1882 * 1883 * Uncomment this macro to respect client's ciphersuite order 1884 */ 1885 //#define MBEDTLS_SSL_SRV_RESPECT_CLIENT_PREFERENCE 1886 1887 /** 1888 * \def MBEDTLS_SSL_MAX_FRAGMENT_LENGTH 1889 * 1890 * Enable support for RFC 6066 max_fragment_length extension in SSL. 1891 * 1892 * Comment this macro to disable support for the max_fragment_length extension 1893 */ 1894 #define MBEDTLS_SSL_MAX_FRAGMENT_LENGTH 1895 1896 /** 1897 * \def MBEDTLS_SSL_PROTO_SSL3 1898 * 1899 * Enable support for SSL 3.0. 1900 * 1901 * Requires: MBEDTLS_MD5_C 1902 * MBEDTLS_SHA1_C 1903 * 1904 * \deprecated This option is deprecated and will be removed in a future 1905 * version of Mbed TLS. 1906 * 1907 * Comment this macro to disable support for SSL 3.0 1908 */ 1909 //#define MBEDTLS_SSL_PROTO_SSL3 1910 1911 /** 1912 * \def MBEDTLS_SSL_PROTO_TLS1 1913 * 1914 * Enable support for TLS 1.0. 1915 * 1916 * Requires: MBEDTLS_MD5_C 1917 * MBEDTLS_SHA1_C 1918 * 1919 * Comment this macro to disable support for TLS 1.0 1920 */ 1921 #define MBEDTLS_SSL_PROTO_TLS1 1922 1923 /** 1924 * \def MBEDTLS_SSL_PROTO_TLS1_1 1925 * 1926 * Enable support for TLS 1.1 (and DTLS 1.0 if DTLS is enabled). 1927 * 1928 * Requires: MBEDTLS_MD5_C 1929 * MBEDTLS_SHA1_C 1930 * 1931 * Comment this macro to disable support for TLS 1.1 / DTLS 1.0 1932 */ 1933 #define MBEDTLS_SSL_PROTO_TLS1_1 1934 1935 /** 1936 * \def MBEDTLS_SSL_PROTO_TLS1_2 1937 * 1938 * Enable support for TLS 1.2 (and DTLS 1.2 if DTLS is enabled). 1939 * 1940 * Requires: MBEDTLS_SHA1_C or MBEDTLS_SHA256_C or MBEDTLS_SHA512_C 1941 * (Depends on ciphersuites) 1942 * 1943 * Comment this macro to disable support for TLS 1.2 / DTLS 1.2 1944 */ 1945 #define MBEDTLS_SSL_PROTO_TLS1_2 1946 1947 /** 1948 * \def MBEDTLS_SSL_PROTO_TLS1_3_EXPERIMENTAL 1949 * 1950 * This macro is used to selectively enable experimental parts 1951 * of the code that contribute to the ongoing development of 1952 * the prototype TLS 1.3 and DTLS 1.3 implementation, and provide 1953 * no other purpose. 1954 * 1955 * \warning TLS 1.3 and DTLS 1.3 aren't yet supported in Mbed TLS, 1956 * and no feature exposed through this macro is part of the 1957 * public API. In particular, features under the control 1958 * of this macro are experimental and don't come with any 1959 * stability guarantees. 1960 * 1961 * Uncomment this macro to enable experimental and partial 1962 * functionality specific to TLS 1.3. 1963 */ 1964 //#define MBEDTLS_SSL_PROTO_TLS1_3_EXPERIMENTAL 1965 1966 /** 1967 * \def MBEDTLS_SSL_PROTO_DTLS 1968 * 1969 * Enable support for DTLS (all available versions). 1970 * 1971 * Enable this and MBEDTLS_SSL_PROTO_TLS1_1 to enable DTLS 1.0, 1972 * and/or this and MBEDTLS_SSL_PROTO_TLS1_2 to enable DTLS 1.2. 1973 * 1974 * Requires: MBEDTLS_SSL_PROTO_TLS1_1 1975 * or MBEDTLS_SSL_PROTO_TLS1_2 1976 * 1977 * Comment this macro to disable support for DTLS 1978 */ 1979 #define MBEDTLS_SSL_PROTO_DTLS 1980 1981 /** 1982 * \def MBEDTLS_SSL_ALPN 1983 * 1984 * Enable support for RFC 7301 Application Layer Protocol Negotiation. 1985 * 1986 * Comment this macro to disable support for ALPN. 1987 */ 1988 #define MBEDTLS_SSL_ALPN 1989 1990 /** 1991 * \def MBEDTLS_SSL_DTLS_ANTI_REPLAY 1992 * 1993 * Enable support for the anti-replay mechanism in DTLS. 1994 * 1995 * Requires: MBEDTLS_SSL_TLS_C 1996 * MBEDTLS_SSL_PROTO_DTLS 1997 * 1998 * \warning Disabling this is often a security risk! 1999 * See mbedtls_ssl_conf_dtls_anti_replay() for details. 2000 * 2001 * Comment this to disable anti-replay in DTLS. 2002 */ 2003 #define MBEDTLS_SSL_DTLS_ANTI_REPLAY 2004 2005 /** 2006 * \def MBEDTLS_SSL_DTLS_HELLO_VERIFY 2007 * 2008 * Enable support for HelloVerifyRequest on DTLS servers. 2009 * 2010 * This feature is highly recommended to prevent DTLS servers being used as 2011 * amplifiers in DoS attacks against other hosts. It should always be enabled 2012 * unless you know for sure amplification cannot be a problem in the 2013 * environment in which your server operates. 2014 * 2015 * \warning Disabling this can be a security risk! (see above) 2016 * 2017 * Requires: MBEDTLS_SSL_PROTO_DTLS 2018 * 2019 * Comment this to disable support for HelloVerifyRequest. 2020 */ 2021 #define MBEDTLS_SSL_DTLS_HELLO_VERIFY 2022 2023 /** 2024 * \def MBEDTLS_SSL_DTLS_SRTP 2025 * 2026 * Enable support for negotiation of DTLS-SRTP (RFC 5764) 2027 * through the use_srtp extension. 2028 * 2029 * \note This feature provides the minimum functionality required 2030 * to negotiate the use of DTLS-SRTP and to allow the derivation of 2031 * the associated SRTP packet protection key material. 2032 * In particular, the SRTP packet protection itself, as well as the 2033 * demultiplexing of RTP and DTLS packets at the datagram layer 2034 * (see Section 5 of RFC 5764), are not handled by this feature. 2035 * Instead, after successful completion of a handshake negotiating 2036 * the use of DTLS-SRTP, the extended key exporter API 2037 * mbedtls_ssl_conf_export_keys_ext_cb() should be used to implement 2038 * the key exporter described in Section 4.2 of RFC 5764 and RFC 5705 2039 * (this is implemented in the SSL example programs). 2040 * The resulting key should then be passed to an SRTP stack. 2041 * 2042 * Setting this option enables the runtime API 2043 * mbedtls_ssl_conf_dtls_srtp_protection_profiles() 2044 * through which the supported DTLS-SRTP protection 2045 * profiles can be configured. You must call this API at 2046 * runtime if you wish to negotiate the use of DTLS-SRTP. 2047 * 2048 * Requires: MBEDTLS_SSL_PROTO_DTLS 2049 * 2050 * Uncomment this to enable support for use_srtp extension. 2051 */ 2052 //#define MBEDTLS_SSL_DTLS_SRTP 2053 2054 /** 2055 * \def MBEDTLS_SSL_DTLS_CLIENT_PORT_REUSE 2056 * 2057 * Enable server-side support for clients that reconnect from the same port. 2058 * 2059 * Some clients unexpectedly close the connection and try to reconnect using the 2060 * same source port. This needs special support from the server to handle the 2061 * new connection securely, as described in section 4.2.8 of RFC 6347. This 2062 * flag enables that support. 2063 * 2064 * Requires: MBEDTLS_SSL_DTLS_HELLO_VERIFY 2065 * 2066 * Comment this to disable support for clients reusing the source port. 2067 */ 2068 #define MBEDTLS_SSL_DTLS_CLIENT_PORT_REUSE 2069 2070 /** 2071 * \def MBEDTLS_SSL_DTLS_BADMAC_LIMIT 2072 * 2073 * Enable support for a limit of records with bad MAC. 2074 * 2075 * See mbedtls_ssl_conf_dtls_badmac_limit(). 2076 * 2077 * Requires: MBEDTLS_SSL_PROTO_DTLS 2078 */ 2079 #define MBEDTLS_SSL_DTLS_BADMAC_LIMIT 2080 2081 /** 2082 * \def MBEDTLS_SSL_SESSION_TICKETS 2083 * 2084 * Enable support for RFC 5077 session tickets in SSL. 2085 * Client-side, provides full support for session tickets (maintenance of a 2086 * session store remains the responsibility of the application, though). 2087 * Server-side, you also need to provide callbacks for writing and parsing 2088 * tickets, including authenticated encryption and key management. Example 2089 * callbacks are provided by MBEDTLS_SSL_TICKET_C. 2090 * 2091 * Comment this macro to disable support for SSL session tickets 2092 */ 2093 #define MBEDTLS_SSL_SESSION_TICKETS 2094 2095 /** 2096 * \def MBEDTLS_SSL_EXPORT_KEYS 2097 * 2098 * Enable support for exporting key block and master secret. 2099 * This is required for certain users of TLS, e.g. EAP-TLS. 2100 * 2101 * Comment this macro to disable support for key export 2102 */ 2103 #define MBEDTLS_SSL_EXPORT_KEYS 2104 2105 /** 2106 * \def MBEDTLS_SSL_SERVER_NAME_INDICATION 2107 * 2108 * Enable support for RFC 6066 server name indication (SNI) in SSL. 2109 * 2110 * Requires: MBEDTLS_X509_CRT_PARSE_C 2111 * 2112 * Comment this macro to disable support for server name indication in SSL 2113 */ 2114 #define MBEDTLS_SSL_SERVER_NAME_INDICATION 2115 2116 /** 2117 * \def MBEDTLS_SSL_TRUNCATED_HMAC 2118 * 2119 * Enable support for RFC 6066 truncated HMAC in SSL. 2120 * 2121 * Comment this macro to disable support for truncated HMAC in SSL 2122 */ 2123 #define MBEDTLS_SSL_TRUNCATED_HMAC 2124 2125 /** 2126 * \def MBEDTLS_SSL_TRUNCATED_HMAC_COMPAT 2127 * 2128 * Fallback to old (pre-2.7), non-conforming implementation of the truncated 2129 * HMAC extension which also truncates the HMAC key. Note that this option is 2130 * only meant for a transitory upgrade period and will be removed in a future 2131 * version of the library. 2132 * 2133 * \warning The old implementation is non-compliant and has a security weakness 2134 * (2^80 brute force attack on the HMAC key used for a single, 2135 * uninterrupted connection). This should only be enabled temporarily 2136 * when (1) the use of truncated HMAC is essential in order to save 2137 * bandwidth, and (2) the peer is an Mbed TLS stack that doesn't use 2138 * the fixed implementation yet (pre-2.7). 2139 * 2140 * \deprecated This option is deprecated and will be removed in a 2141 * future version of Mbed TLS. 2142 * 2143 * Uncomment to fallback to old, non-compliant truncated HMAC implementation. 2144 * 2145 * Requires: MBEDTLS_SSL_TRUNCATED_HMAC 2146 */ 2147 //#define MBEDTLS_SSL_TRUNCATED_HMAC_COMPAT 2148 2149 /** 2150 * \def MBEDTLS_SSL_VARIABLE_BUFFER_LENGTH 2151 * 2152 * When this option is enabled, the SSL buffer will be resized automatically 2153 * based on the negotiated maximum fragment length in each direction. 2154 * 2155 * Requires: MBEDTLS_SSL_MAX_FRAGMENT_LENGTH 2156 */ 2157 //#define MBEDTLS_SSL_VARIABLE_BUFFER_LENGTH 2158 2159 /** 2160 * Allow SHA-1 in the default TLS configuration for TLS 1.2 handshake 2161 * signature and ciphersuite selection. Without this build-time option, SHA-1 2162 * support must be activated explicitly through mbedtls_ssl_conf_sig_hashes. 2163 * The use of SHA-1 in TLS <= 1.1 and in HMAC-SHA-1 is always allowed by 2164 * default. At the time of writing, there is no practical attack on the use 2165 * of SHA-1 in handshake signatures, hence this option is turned on by default 2166 * to preserve compatibility with existing peers, but the general 2167 * warning applies nonetheless: 2168 * 2169 * \warning SHA-1 is considered a weak message digest and its use constitutes 2170 * a security risk. If possible, we recommend avoiding dependencies 2171 * on it, and considering stronger message digests instead. 2172 * 2173 */ 2174 //#define MBEDTLS_TLS_DEFAULT_ALLOW_SHA1_IN_KEY_EXCHANGE 2175 2176 /** 2177 * \def MBEDTLS_TEST_CONSTANT_FLOW_MEMSAN 2178 * 2179 * Enable testing of the constant-flow nature of some sensitive functions with 2180 * clang's MemorySanitizer. This causes some existing tests to also test 2181 * this non-functional property of the code under test. 2182 * 2183 * This setting requires compiling with clang -fsanitize=memory. The test 2184 * suites can then be run normally. 2185 * 2186 * \warning This macro is only used for extended testing; it is not considered 2187 * part of the library's API, so it may change or disappear at any time. 2188 * 2189 * Uncomment to enable testing of the constant-flow nature of selected code. 2190 */ 2191 //#define MBEDTLS_TEST_CONSTANT_FLOW_MEMSAN 2192 2193 /** 2194 * \def MBEDTLS_TEST_CONSTANT_FLOW_VALGRIND 2195 * 2196 * Enable testing of the constant-flow nature of some sensitive functions with 2197 * valgrind's memcheck tool. This causes some existing tests to also test 2198 * this non-functional property of the code under test. 2199 * 2200 * This setting requires valgrind headers for building, and is only useful for 2201 * testing if the tests suites are run with valgrind's memcheck. This can be 2202 * done for an individual test suite with 'valgrind ./test_suite_xxx', or when 2203 * using CMake, this can be done for all test suites with 'make memcheck'. 2204 * 2205 * \warning This macro is only used for extended testing; it is not considered 2206 * part of the library's API, so it may change or disappear at any time. 2207 * 2208 * Uncomment to enable testing of the constant-flow nature of selected code. 2209 */ 2210 //#define MBEDTLS_TEST_CONSTANT_FLOW_VALGRIND 2211 2212 /** 2213 * \def MBEDTLS_TEST_HOOKS 2214 * 2215 * Enable features for invasive testing such as introspection functions and 2216 * hooks for fault injection. This enables additional unit tests. 2217 * 2218 * Merely enabling this feature should not change the behavior of the product. 2219 * It only adds new code, and new branching points where the default behavior 2220 * is the same as when this feature is disabled. 2221 * However, this feature increases the attack surface: there is an added 2222 * risk of vulnerabilities, and more gadgets that can make exploits easier. 2223 * Therefore this feature must never be enabled in production. 2224 * 2225 * See `docs/architecture/testing/mbed-crypto-invasive-testing.md` for more 2226 * information. 2227 * 2228 * Uncomment to enable invasive tests. 2229 */ 2230 //#define MBEDTLS_TEST_HOOKS 2231 2232 /** 2233 * \def MBEDTLS_THREADING_ALT 2234 * 2235 * Provide your own alternate threading implementation. 2236 * 2237 * Requires: MBEDTLS_THREADING_C 2238 * 2239 * Uncomment this to allow your own alternate threading implementation. 2240 */ 2241 //#define MBEDTLS_THREADING_ALT 2242 2243 /** 2244 * \def MBEDTLS_THREADING_PTHREAD 2245 * 2246 * Enable the pthread wrapper layer for the threading layer. 2247 * 2248 * Requires: MBEDTLS_THREADING_C 2249 * 2250 * Uncomment this to enable pthread mutexes. 2251 */ 2252 //#define MBEDTLS_THREADING_PTHREAD 2253 2254 /** 2255 * \def MBEDTLS_USE_PSA_CRYPTO 2256 * 2257 * Make the X.509 and TLS library use PSA for cryptographic operations, and 2258 * enable new APIs for using keys handled by PSA Crypto. 2259 * 2260 * \note Development of this option is currently in progress, and parts of Mbed 2261 * TLS's X.509 and TLS modules are not ported to PSA yet. However, these parts 2262 * will still continue to work as usual, so enabling this option should not 2263 * break backwards compatibility. 2264 * 2265 * \note See docs/use-psa-crypto.md for a complete description of what this 2266 * option currently does, and of parts that are not affected by it so far. 2267 * 2268 * \warning This option enables new Mbed TLS APIs which are currently 2269 * considered experimental and may change in incompatible ways at any time. 2270 * That is, the APIs enabled by this option are not covered by the usual 2271 * promises of API stability. 2272 * 2273 * Requires: MBEDTLS_PSA_CRYPTO_C. 2274 * 2275 * Uncomment this to enable internal use of PSA Crypto and new associated APIs. 2276 */ 2277 //#define MBEDTLS_USE_PSA_CRYPTO 2278 2279 /** 2280 * \def MBEDTLS_PSA_CRYPTO_CONFIG 2281 * 2282 * This setting allows support for cryptographic mechanisms through the PSA 2283 * API to be configured separately from support through the mbedtls API. 2284 * 2285 * When this option is disabled, the PSA API exposes the cryptographic 2286 * mechanisms that can be implemented on top of the `mbedtls_xxx` API 2287 * configured with `MBEDTLS_XXX` symbols. 2288 * 2289 * When this option is enabled, the PSA API exposes the cryptographic 2290 * mechanisms requested by the `PSA_WANT_XXX` symbols defined in 2291 * include/psa/crypto_config.h. The corresponding `MBEDTLS_XXX` settings are 2292 * automatically enabled if required (i.e. if no PSA driver provides the 2293 * mechanism). You may still freely enable additional `MBEDTLS_XXX` symbols 2294 * in config.h. 2295 * 2296 * If the symbol #MBEDTLS_PSA_CRYPTO_CONFIG_FILE is defined, it specifies 2297 * an alternative header to include instead of include/psa/crypto_config.h. 2298 * 2299 * If you enable this option and write your own configuration file, you must 2300 * include mbedtls/config_psa.h in your configuration file. The default 2301 * provided mbedtls/config.h contains the necessary inclusion. 2302 * 2303 * This feature is still experimental and is not ready for production since 2304 * it is not completed. 2305 */ 2306 //#define MBEDTLS_PSA_CRYPTO_CONFIG 2307 2308 /** 2309 * \def MBEDTLS_VERSION_FEATURES 2310 * 2311 * Allow run-time checking of compile-time enabled features. Thus allowing users 2312 * to check at run-time if the library is for instance compiled with threading 2313 * support via mbedtls_version_check_feature(). 2314 * 2315 * Requires: MBEDTLS_VERSION_C 2316 * 2317 * Comment this to disable run-time checking and save ROM space 2318 */ 2319 #define MBEDTLS_VERSION_FEATURES 2320 2321 /** 2322 * \def MBEDTLS_X509_ALLOW_EXTENSIONS_NON_V3 2323 * 2324 * If set, the X509 parser will not break-off when parsing an X509 certificate 2325 * and encountering an extension in a v1 or v2 certificate. 2326 * 2327 * Uncomment to prevent an error. 2328 */ 2329 //#define MBEDTLS_X509_ALLOW_EXTENSIONS_NON_V3 2330 2331 /** 2332 * \def MBEDTLS_X509_ALLOW_UNSUPPORTED_CRITICAL_EXTENSION 2333 * 2334 * If set, the X509 parser will not break-off when parsing an X509 certificate 2335 * and encountering an unknown critical extension. 2336 * 2337 * \warning Depending on your PKI use, enabling this can be a security risk! 2338 * 2339 * Uncomment to prevent an error. 2340 */ 2341 //#define MBEDTLS_X509_ALLOW_UNSUPPORTED_CRITICAL_EXTENSION 2342 2343 /** 2344 * \def MBEDTLS_X509_TRUSTED_CERTIFICATE_CALLBACK 2345 * 2346 * If set, this enables the X.509 API `mbedtls_x509_crt_verify_with_ca_cb()` 2347 * and the SSL API `mbedtls_ssl_conf_ca_cb()` which allow users to configure 2348 * the set of trusted certificates through a callback instead of a linked 2349 * list. 2350 * 2351 * This is useful for example in environments where a large number of trusted 2352 * certificates is present and storing them in a linked list isn't efficient 2353 * enough, or when the set of trusted certificates changes frequently. 2354 * 2355 * See the documentation of `mbedtls_x509_crt_verify_with_ca_cb()` and 2356 * `mbedtls_ssl_conf_ca_cb()` for more information. 2357 * 2358 * Uncomment to enable trusted certificate callbacks. 2359 */ 2360 //#define MBEDTLS_X509_TRUSTED_CERTIFICATE_CALLBACK 2361 2362 /** 2363 * \def MBEDTLS_X509_CHECK_KEY_USAGE 2364 * 2365 * Enable verification of the keyUsage extension (CA and leaf certificates). 2366 * 2367 * Disabling this avoids problems with mis-issued and/or misused 2368 * (intermediate) CA and leaf certificates. 2369 * 2370 * \warning Depending on your PKI use, disabling this can be a security risk! 2371 * 2372 * Comment to skip keyUsage checking for both CA and leaf certificates. 2373 */ 2374 #define MBEDTLS_X509_CHECK_KEY_USAGE 2375 2376 /** 2377 * \def MBEDTLS_X509_CHECK_EXTENDED_KEY_USAGE 2378 * 2379 * Enable verification of the extendedKeyUsage extension (leaf certificates). 2380 * 2381 * Disabling this avoids problems with mis-issued and/or misused certificates. 2382 * 2383 * \warning Depending on your PKI use, disabling this can be a security risk! 2384 * 2385 * Comment to skip extendedKeyUsage checking for certificates. 2386 */ 2387 #define MBEDTLS_X509_CHECK_EXTENDED_KEY_USAGE 2388 2389 /** 2390 * \def MBEDTLS_X509_RSASSA_PSS_SUPPORT 2391 * 2392 * Enable parsing and verification of X.509 certificates, CRLs and CSRS 2393 * signed with RSASSA-PSS (aka PKCS#1 v2.1). 2394 * 2395 * Comment this macro to disallow using RSASSA-PSS in certificates. 2396 */ 2397 #define MBEDTLS_X509_RSASSA_PSS_SUPPORT 2398 2399 /** 2400 * \def MBEDTLS_ZLIB_SUPPORT 2401 * 2402 * If set, the SSL/TLS module uses ZLIB to support compression and 2403 * decompression of packet data. 2404 * 2405 * \warning TLS-level compression MAY REDUCE SECURITY! See for example the 2406 * CRIME attack. Before enabling this option, you should examine with care if 2407 * CRIME or similar exploits may be applicable to your use case. 2408 * 2409 * \note Currently compression can't be used with DTLS. 2410 * 2411 * \deprecated This feature is deprecated and will be removed 2412 * in the next major revision of the library. 2413 * 2414 * Used in: library/ssl_tls.c 2415 * library/ssl_cli.c 2416 * library/ssl_srv.c 2417 * 2418 * This feature requires zlib library and headers to be present. 2419 * 2420 * Uncomment to enable use of ZLIB 2421 */ 2422 //#define MBEDTLS_ZLIB_SUPPORT 2423 /** \} name SECTION: Mbed TLS feature support */ 2424 2425 /** 2426 * \name SECTION: Mbed TLS modules 2427 * 2428 * This section enables or disables entire modules in Mbed TLS 2429 * \{ 2430 */ 2431 2432 /** 2433 * \def MBEDTLS_AESNI_C 2434 * 2435 * Enable AES-NI support on x86-64 or x86-32. 2436 * 2437 * \note AESNI is only supported with certain compilers and target options: 2438 * - Visual Studio 2013: supported. 2439 * - GCC, x86-64, target not explicitly supporting AESNI: 2440 * requires MBEDTLS_HAVE_ASM. 2441 * - GCC, x86-32, target not explicitly supporting AESNI: 2442 * not supported. 2443 * - GCC, x86-64 or x86-32, target supporting AESNI: supported. 2444 * For this assembly-less implementation, you must currently compile 2445 * `library/aesni.c` and `library/aes.c` with machine options to enable 2446 * SSE2 and AESNI instructions: `gcc -msse2 -maes -mpclmul` or 2447 * `clang -maes -mpclmul`. 2448 * - Non-x86 targets: this option is silently ignored. 2449 * - Other compilers: this option is silently ignored. 2450 * 2451 * \note 2452 * Above, "GCC" includes compatible compilers such as Clang. 2453 * The limitations on target support are likely to be relaxed in the future. 2454 * 2455 * Module: library/aesni.c 2456 * Caller: library/aes.c 2457 * 2458 * Requires: MBEDTLS_HAVE_ASM (on some platforms, see note) 2459 * 2460 * This modules adds support for the AES-NI instructions on x86. 2461 */ 2462 #define MBEDTLS_AESNI_C 2463 2464 /** 2465 * \def MBEDTLS_AES_C 2466 * 2467 * Enable the AES block cipher. 2468 * 2469 * Module: library/aes.c 2470 * Caller: library/cipher.c 2471 * library/pem.c 2472 * library/ctr_drbg.c 2473 * 2474 * This module enables the following ciphersuites (if other requisites are 2475 * enabled as well): 2476 * MBEDTLS_TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA 2477 * MBEDTLS_TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA 2478 * MBEDTLS_TLS_ECDH_RSA_WITH_AES_128_CBC_SHA 2479 * MBEDTLS_TLS_ECDH_RSA_WITH_AES_256_CBC_SHA 2480 * MBEDTLS_TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA256 2481 * MBEDTLS_TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA384 2482 * MBEDTLS_TLS_ECDH_RSA_WITH_AES_128_CBC_SHA256 2483 * MBEDTLS_TLS_ECDH_RSA_WITH_AES_256_CBC_SHA384 2484 * MBEDTLS_TLS_ECDH_ECDSA_WITH_AES_128_GCM_SHA256 2485 * MBEDTLS_TLS_ECDH_ECDSA_WITH_AES_256_GCM_SHA384 2486 * MBEDTLS_TLS_ECDH_RSA_WITH_AES_128_GCM_SHA256 2487 * MBEDTLS_TLS_ECDH_RSA_WITH_AES_256_GCM_SHA384 2488 * MBEDTLS_TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384 2489 * MBEDTLS_TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 2490 * MBEDTLS_TLS_DHE_RSA_WITH_AES_256_GCM_SHA384 2491 * MBEDTLS_TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384 2492 * MBEDTLS_TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384 2493 * MBEDTLS_TLS_DHE_RSA_WITH_AES_256_CBC_SHA256 2494 * MBEDTLS_TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA 2495 * MBEDTLS_TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA 2496 * MBEDTLS_TLS_DHE_RSA_WITH_AES_256_CBC_SHA 2497 * MBEDTLS_TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256 2498 * MBEDTLS_TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256 2499 * MBEDTLS_TLS_DHE_RSA_WITH_AES_128_GCM_SHA256 2500 * MBEDTLS_TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256 2501 * MBEDTLS_TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256 2502 * MBEDTLS_TLS_DHE_RSA_WITH_AES_128_CBC_SHA256 2503 * MBEDTLS_TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA 2504 * MBEDTLS_TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA 2505 * MBEDTLS_TLS_DHE_RSA_WITH_AES_128_CBC_SHA 2506 * MBEDTLS_TLS_DHE_PSK_WITH_AES_256_GCM_SHA384 2507 * MBEDTLS_TLS_ECDHE_PSK_WITH_AES_256_CBC_SHA384 2508 * MBEDTLS_TLS_DHE_PSK_WITH_AES_256_CBC_SHA384 2509 * MBEDTLS_TLS_ECDHE_PSK_WITH_AES_256_CBC_SHA 2510 * MBEDTLS_TLS_DHE_PSK_WITH_AES_256_CBC_SHA 2511 * MBEDTLS_TLS_DHE_PSK_WITH_AES_128_GCM_SHA256 2512 * MBEDTLS_TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA256 2513 * MBEDTLS_TLS_DHE_PSK_WITH_AES_128_CBC_SHA256 2514 * MBEDTLS_TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA 2515 * MBEDTLS_TLS_DHE_PSK_WITH_AES_128_CBC_SHA 2516 * MBEDTLS_TLS_RSA_WITH_AES_256_GCM_SHA384 2517 * MBEDTLS_TLS_RSA_WITH_AES_256_CBC_SHA256 2518 * MBEDTLS_TLS_RSA_WITH_AES_256_CBC_SHA 2519 * MBEDTLS_TLS_RSA_WITH_AES_128_GCM_SHA256 2520 * MBEDTLS_TLS_RSA_WITH_AES_128_CBC_SHA256 2521 * MBEDTLS_TLS_RSA_WITH_AES_128_CBC_SHA 2522 * MBEDTLS_TLS_RSA_PSK_WITH_AES_256_GCM_SHA384 2523 * MBEDTLS_TLS_RSA_PSK_WITH_AES_256_CBC_SHA384 2524 * MBEDTLS_TLS_RSA_PSK_WITH_AES_256_CBC_SHA 2525 * MBEDTLS_TLS_RSA_PSK_WITH_AES_128_GCM_SHA256 2526 * MBEDTLS_TLS_RSA_PSK_WITH_AES_128_CBC_SHA256 2527 * MBEDTLS_TLS_RSA_PSK_WITH_AES_128_CBC_SHA 2528 * MBEDTLS_TLS_PSK_WITH_AES_256_GCM_SHA384 2529 * MBEDTLS_TLS_PSK_WITH_AES_256_CBC_SHA384 2530 * MBEDTLS_TLS_PSK_WITH_AES_256_CBC_SHA 2531 * MBEDTLS_TLS_PSK_WITH_AES_128_GCM_SHA256 2532 * MBEDTLS_TLS_PSK_WITH_AES_128_CBC_SHA256 2533 * MBEDTLS_TLS_PSK_WITH_AES_128_CBC_SHA 2534 * 2535 * PEM_PARSE uses AES for decrypting encrypted keys. 2536 */ 2537 #define MBEDTLS_AES_C 2538 2539 /** 2540 * \def MBEDTLS_ARC4_C 2541 * 2542 * Enable the ARCFOUR stream cipher. 2543 * 2544 * Module: library/arc4.c 2545 * Caller: library/cipher.c 2546 * 2547 * This module enables the following ciphersuites (if other requisites are 2548 * enabled as well): 2549 * MBEDTLS_TLS_ECDH_ECDSA_WITH_RC4_128_SHA 2550 * MBEDTLS_TLS_ECDH_RSA_WITH_RC4_128_SHA 2551 * MBEDTLS_TLS_ECDHE_ECDSA_WITH_RC4_128_SHA 2552 * MBEDTLS_TLS_ECDHE_RSA_WITH_RC4_128_SHA 2553 * MBEDTLS_TLS_ECDHE_PSK_WITH_RC4_128_SHA 2554 * MBEDTLS_TLS_DHE_PSK_WITH_RC4_128_SHA 2555 * MBEDTLS_TLS_RSA_WITH_RC4_128_SHA 2556 * MBEDTLS_TLS_RSA_WITH_RC4_128_MD5 2557 * MBEDTLS_TLS_RSA_PSK_WITH_RC4_128_SHA 2558 * MBEDTLS_TLS_PSK_WITH_RC4_128_SHA 2559 * 2560 * \warning ARC4 is considered a weak cipher and its use constitutes a 2561 * security risk. If possible, we recommend avoiding dependencies on 2562 * it, and considering stronger ciphers instead. 2563 * 2564 */ 2565 #define MBEDTLS_ARC4_C 2566 2567 /** 2568 * \def MBEDTLS_ASN1_PARSE_C 2569 * 2570 * Enable the generic ASN1 parser. 2571 * 2572 * Module: library/asn1.c 2573 * Caller: library/x509.c 2574 * library/dhm.c 2575 * library/pkcs12.c 2576 * library/pkcs5.c 2577 * library/pkparse.c 2578 */ 2579 #define MBEDTLS_ASN1_PARSE_C 2580 2581 /** 2582 * \def MBEDTLS_ASN1_WRITE_C 2583 * 2584 * Enable the generic ASN1 writer. 2585 * 2586 * Module: library/asn1write.c 2587 * Caller: library/ecdsa.c 2588 * library/pkwrite.c 2589 * library/x509_create.c 2590 * library/x509write_crt.c 2591 * library/x509write_csr.c 2592 */ 2593 #define MBEDTLS_ASN1_WRITE_C 2594 2595 /** 2596 * \def MBEDTLS_BASE64_C 2597 * 2598 * Enable the Base64 module. 2599 * 2600 * Module: library/base64.c 2601 * Caller: library/pem.c 2602 * 2603 * This module is required for PEM support (required by X.509). 2604 */ 2605 #define MBEDTLS_BASE64_C 2606 2607 /** 2608 * \def MBEDTLS_BIGNUM_C 2609 * 2610 * Enable the multi-precision integer library. 2611 * 2612 * Module: library/bignum.c 2613 * Caller: library/dhm.c 2614 * library/ecp.c 2615 * library/ecdsa.c 2616 * library/rsa.c 2617 * library/rsa_internal.c 2618 * library/ssl_tls.c 2619 * 2620 * This module is required for RSA, DHM and ECC (ECDH, ECDSA) support. 2621 */ 2622 #define MBEDTLS_BIGNUM_C 2623 2624 /** 2625 * \def MBEDTLS_BLOWFISH_C 2626 * 2627 * Enable the Blowfish block cipher. 2628 * 2629 * Module: library/blowfish.c 2630 */ 2631 #define MBEDTLS_BLOWFISH_C 2632 2633 /** 2634 * \def MBEDTLS_CAMELLIA_C 2635 * 2636 * Enable the Camellia block cipher. 2637 * 2638 * Module: library/camellia.c 2639 * Caller: library/cipher.c 2640 * 2641 * This module enables the following ciphersuites (if other requisites are 2642 * enabled as well): 2643 * MBEDTLS_TLS_ECDH_ECDSA_WITH_CAMELLIA_128_CBC_SHA256 2644 * MBEDTLS_TLS_ECDH_ECDSA_WITH_CAMELLIA_256_CBC_SHA384 2645 * MBEDTLS_TLS_ECDH_RSA_WITH_CAMELLIA_128_CBC_SHA256 2646 * MBEDTLS_TLS_ECDH_RSA_WITH_CAMELLIA_256_CBC_SHA384 2647 * MBEDTLS_TLS_ECDH_ECDSA_WITH_CAMELLIA_128_GCM_SHA256 2648 * MBEDTLS_TLS_ECDH_ECDSA_WITH_CAMELLIA_256_GCM_SHA384 2649 * MBEDTLS_TLS_ECDH_RSA_WITH_CAMELLIA_128_GCM_SHA256 2650 * MBEDTLS_TLS_ECDH_RSA_WITH_CAMELLIA_256_GCM_SHA384 2651 * MBEDTLS_TLS_ECDHE_ECDSA_WITH_CAMELLIA_256_GCM_SHA384 2652 * MBEDTLS_TLS_ECDHE_RSA_WITH_CAMELLIA_256_GCM_SHA384 2653 * MBEDTLS_TLS_DHE_RSA_WITH_CAMELLIA_256_GCM_SHA384 2654 * MBEDTLS_TLS_ECDHE_ECDSA_WITH_CAMELLIA_256_CBC_SHA384 2655 * MBEDTLS_TLS_ECDHE_RSA_WITH_CAMELLIA_256_CBC_SHA384 2656 * MBEDTLS_TLS_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA256 2657 * MBEDTLS_TLS_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA 2658 * MBEDTLS_TLS_ECDHE_ECDSA_WITH_CAMELLIA_128_GCM_SHA256 2659 * MBEDTLS_TLS_ECDHE_RSA_WITH_CAMELLIA_128_GCM_SHA256 2660 * MBEDTLS_TLS_DHE_RSA_WITH_CAMELLIA_128_GCM_SHA256 2661 * MBEDTLS_TLS_ECDHE_ECDSA_WITH_CAMELLIA_128_CBC_SHA256 2662 * MBEDTLS_TLS_ECDHE_RSA_WITH_CAMELLIA_128_CBC_SHA256 2663 * MBEDTLS_TLS_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA256 2664 * MBEDTLS_TLS_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA 2665 * MBEDTLS_TLS_DHE_PSK_WITH_CAMELLIA_256_GCM_SHA384 2666 * MBEDTLS_TLS_ECDHE_PSK_WITH_CAMELLIA_256_CBC_SHA384 2667 * MBEDTLS_TLS_DHE_PSK_WITH_CAMELLIA_256_CBC_SHA384 2668 * MBEDTLS_TLS_DHE_PSK_WITH_CAMELLIA_128_GCM_SHA256 2669 * MBEDTLS_TLS_DHE_PSK_WITH_CAMELLIA_128_CBC_SHA256 2670 * MBEDTLS_TLS_ECDHE_PSK_WITH_CAMELLIA_128_CBC_SHA256 2671 * MBEDTLS_TLS_RSA_WITH_CAMELLIA_256_GCM_SHA384 2672 * MBEDTLS_TLS_RSA_WITH_CAMELLIA_256_CBC_SHA256 2673 * MBEDTLS_TLS_RSA_WITH_CAMELLIA_256_CBC_SHA 2674 * MBEDTLS_TLS_RSA_WITH_CAMELLIA_128_GCM_SHA256 2675 * MBEDTLS_TLS_RSA_WITH_CAMELLIA_128_CBC_SHA256 2676 * MBEDTLS_TLS_RSA_WITH_CAMELLIA_128_CBC_SHA 2677 * MBEDTLS_TLS_RSA_PSK_WITH_CAMELLIA_256_GCM_SHA384 2678 * MBEDTLS_TLS_RSA_PSK_WITH_CAMELLIA_256_CBC_SHA384 2679 * MBEDTLS_TLS_RSA_PSK_WITH_CAMELLIA_128_GCM_SHA256 2680 * MBEDTLS_TLS_RSA_PSK_WITH_CAMELLIA_128_CBC_SHA256 2681 * MBEDTLS_TLS_PSK_WITH_CAMELLIA_256_GCM_SHA384 2682 * MBEDTLS_TLS_PSK_WITH_CAMELLIA_256_CBC_SHA384 2683 * MBEDTLS_TLS_PSK_WITH_CAMELLIA_128_GCM_SHA256 2684 * MBEDTLS_TLS_PSK_WITH_CAMELLIA_128_CBC_SHA256 2685 */ 2686 #define MBEDTLS_CAMELLIA_C 2687 2688 /** 2689 * \def MBEDTLS_ARIA_C 2690 * 2691 * Enable the ARIA block cipher. 2692 * 2693 * Module: library/aria.c 2694 * Caller: library/cipher.c 2695 * 2696 * This module enables the following ciphersuites (if other requisites are 2697 * enabled as well): 2698 * 2699 * MBEDTLS_TLS_RSA_WITH_ARIA_128_CBC_SHA256 2700 * MBEDTLS_TLS_RSA_WITH_ARIA_256_CBC_SHA384 2701 * MBEDTLS_TLS_DHE_RSA_WITH_ARIA_128_CBC_SHA256 2702 * MBEDTLS_TLS_DHE_RSA_WITH_ARIA_256_CBC_SHA384 2703 * MBEDTLS_TLS_ECDHE_ECDSA_WITH_ARIA_128_CBC_SHA256 2704 * MBEDTLS_TLS_ECDHE_ECDSA_WITH_ARIA_256_CBC_SHA384 2705 * MBEDTLS_TLS_ECDH_ECDSA_WITH_ARIA_128_CBC_SHA256 2706 * MBEDTLS_TLS_ECDH_ECDSA_WITH_ARIA_256_CBC_SHA384 2707 * MBEDTLS_TLS_ECDHE_RSA_WITH_ARIA_128_CBC_SHA256 2708 * MBEDTLS_TLS_ECDHE_RSA_WITH_ARIA_256_CBC_SHA384 2709 * MBEDTLS_TLS_ECDH_RSA_WITH_ARIA_128_CBC_SHA256 2710 * MBEDTLS_TLS_ECDH_RSA_WITH_ARIA_256_CBC_SHA384 2711 * MBEDTLS_TLS_RSA_WITH_ARIA_128_GCM_SHA256 2712 * MBEDTLS_TLS_RSA_WITH_ARIA_256_GCM_SHA384 2713 * MBEDTLS_TLS_DHE_RSA_WITH_ARIA_128_GCM_SHA256 2714 * MBEDTLS_TLS_DHE_RSA_WITH_ARIA_256_GCM_SHA384 2715 * MBEDTLS_TLS_ECDHE_ECDSA_WITH_ARIA_128_GCM_SHA256 2716 * MBEDTLS_TLS_ECDHE_ECDSA_WITH_ARIA_256_GCM_SHA384 2717 * MBEDTLS_TLS_ECDH_ECDSA_WITH_ARIA_128_GCM_SHA256 2718 * MBEDTLS_TLS_ECDH_ECDSA_WITH_ARIA_256_GCM_SHA384 2719 * MBEDTLS_TLS_ECDHE_RSA_WITH_ARIA_128_GCM_SHA256 2720 * MBEDTLS_TLS_ECDHE_RSA_WITH_ARIA_256_GCM_SHA384 2721 * MBEDTLS_TLS_ECDH_RSA_WITH_ARIA_128_GCM_SHA256 2722 * MBEDTLS_TLS_ECDH_RSA_WITH_ARIA_256_GCM_SHA384 2723 * MBEDTLS_TLS_PSK_WITH_ARIA_128_CBC_SHA256 2724 * MBEDTLS_TLS_PSK_WITH_ARIA_256_CBC_SHA384 2725 * MBEDTLS_TLS_DHE_PSK_WITH_ARIA_128_CBC_SHA256 2726 * MBEDTLS_TLS_DHE_PSK_WITH_ARIA_256_CBC_SHA384 2727 * MBEDTLS_TLS_RSA_PSK_WITH_ARIA_128_CBC_SHA256 2728 * MBEDTLS_TLS_RSA_PSK_WITH_ARIA_256_CBC_SHA384 2729 * MBEDTLS_TLS_PSK_WITH_ARIA_128_GCM_SHA256 2730 * MBEDTLS_TLS_PSK_WITH_ARIA_256_GCM_SHA384 2731 * MBEDTLS_TLS_DHE_PSK_WITH_ARIA_128_GCM_SHA256 2732 * MBEDTLS_TLS_DHE_PSK_WITH_ARIA_256_GCM_SHA384 2733 * MBEDTLS_TLS_RSA_PSK_WITH_ARIA_128_GCM_SHA256 2734 * MBEDTLS_TLS_RSA_PSK_WITH_ARIA_256_GCM_SHA384 2735 * MBEDTLS_TLS_ECDHE_PSK_WITH_ARIA_128_CBC_SHA256 2736 * MBEDTLS_TLS_ECDHE_PSK_WITH_ARIA_256_CBC_SHA384 2737 */ 2738 //#define MBEDTLS_ARIA_C 2739 2740 /** 2741 * \def MBEDTLS_CCM_C 2742 * 2743 * Enable the Counter with CBC-MAC (CCM) mode for 128-bit block cipher. 2744 * 2745 * Module: library/ccm.c 2746 * 2747 * Requires: MBEDTLS_AES_C or MBEDTLS_CAMELLIA_C 2748 * 2749 * This module enables the AES-CCM ciphersuites, if other requisites are 2750 * enabled as well. 2751 */ 2752 #define MBEDTLS_CCM_C 2753 2754 /** 2755 * \def MBEDTLS_CERTS_C 2756 * 2757 * Enable the test certificates. 2758 * 2759 * Module: library/certs.c 2760 * Caller: 2761 * 2762 * This module is used for testing (ssl_client/server). 2763 */ 2764 #define MBEDTLS_CERTS_C 2765 2766 /** 2767 * \def MBEDTLS_CHACHA20_C 2768 * 2769 * Enable the ChaCha20 stream cipher. 2770 * 2771 * Module: library/chacha20.c 2772 */ 2773 #define MBEDTLS_CHACHA20_C 2774 2775 /** 2776 * \def MBEDTLS_CHACHAPOLY_C 2777 * 2778 * Enable the ChaCha20-Poly1305 AEAD algorithm. 2779 * 2780 * Module: library/chachapoly.c 2781 * 2782 * This module requires: MBEDTLS_CHACHA20_C, MBEDTLS_POLY1305_C 2783 */ 2784 #define MBEDTLS_CHACHAPOLY_C 2785 2786 /** 2787 * \def MBEDTLS_CIPHER_C 2788 * 2789 * Enable the generic cipher layer. 2790 * 2791 * Module: library/cipher.c 2792 * Caller: library/ssl_tls.c 2793 * 2794 * Uncomment to enable generic cipher wrappers. 2795 */ 2796 #define MBEDTLS_CIPHER_C 2797 2798 /** 2799 * \def MBEDTLS_CMAC_C 2800 * 2801 * Enable the CMAC (Cipher-based Message Authentication Code) mode for block 2802 * ciphers. 2803 * 2804 * \note When #MBEDTLS_CMAC_ALT is active, meaning that the underlying 2805 * implementation of the CMAC algorithm is provided by an alternate 2806 * implementation, that alternate implementation may opt to not support 2807 * AES-192 or 3DES as underlying block ciphers for the CMAC operation. 2808 * 2809 * Module: library/cmac.c 2810 * 2811 * Requires: MBEDTLS_AES_C or MBEDTLS_DES_C 2812 * 2813 */ 2814 //#define MBEDTLS_CMAC_C 2815 2816 /** 2817 * \def MBEDTLS_CTR_DRBG_C 2818 * 2819 * Enable the CTR_DRBG AES-based random generator. 2820 * The CTR_DRBG generator uses AES-256 by default. 2821 * To use AES-128 instead, enable \c MBEDTLS_CTR_DRBG_USE_128_BIT_KEY above. 2822 * 2823 * \note To achieve a 256-bit security strength with CTR_DRBG, 2824 * you must use AES-256 *and* use sufficient entropy. 2825 * See ctr_drbg.h for more details. 2826 * 2827 * Module: library/ctr_drbg.c 2828 * Caller: 2829 * 2830 * Requires: MBEDTLS_AES_C 2831 * 2832 * This module provides the CTR_DRBG AES random number generator. 2833 */ 2834 #define MBEDTLS_CTR_DRBG_C 2835 2836 /** 2837 * \def MBEDTLS_DEBUG_C 2838 * 2839 * Enable the debug functions. 2840 * 2841 * Module: library/debug.c 2842 * Caller: library/ssl_cli.c 2843 * library/ssl_srv.c 2844 * library/ssl_tls.c 2845 * 2846 * This module provides debugging functions. 2847 */ 2848 #define MBEDTLS_DEBUG_C 2849 2850 /** 2851 * \def MBEDTLS_DES_C 2852 * 2853 * Enable the DES block cipher. 2854 * 2855 * Module: library/des.c 2856 * Caller: library/pem.c 2857 * library/cipher.c 2858 * 2859 * This module enables the following ciphersuites (if other requisites are 2860 * enabled as well): 2861 * MBEDTLS_TLS_ECDH_ECDSA_WITH_3DES_EDE_CBC_SHA 2862 * MBEDTLS_TLS_ECDH_RSA_WITH_3DES_EDE_CBC_SHA 2863 * MBEDTLS_TLS_ECDHE_ECDSA_WITH_3DES_EDE_CBC_SHA 2864 * MBEDTLS_TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA 2865 * MBEDTLS_TLS_DHE_RSA_WITH_3DES_EDE_CBC_SHA 2866 * MBEDTLS_TLS_ECDHE_PSK_WITH_3DES_EDE_CBC_SHA 2867 * MBEDTLS_TLS_DHE_PSK_WITH_3DES_EDE_CBC_SHA 2868 * MBEDTLS_TLS_RSA_WITH_3DES_EDE_CBC_SHA 2869 * MBEDTLS_TLS_RSA_PSK_WITH_3DES_EDE_CBC_SHA 2870 * MBEDTLS_TLS_PSK_WITH_3DES_EDE_CBC_SHA 2871 * 2872 * PEM_PARSE uses DES/3DES for decrypting encrypted keys. 2873 * 2874 * \warning DES/3DES are considered weak ciphers and their use constitutes a 2875 * security risk. We recommend considering stronger ciphers instead. 2876 */ 2877 #define MBEDTLS_DES_C 2878 2879 /** 2880 * \def MBEDTLS_DHM_C 2881 * 2882 * Enable the Diffie-Hellman-Merkle module. 2883 * 2884 * Module: library/dhm.c 2885 * Caller: library/ssl_cli.c 2886 * library/ssl_srv.c 2887 * 2888 * This module is used by the following key exchanges: 2889 * DHE-RSA, DHE-PSK 2890 * 2891 * \warning Using DHE constitutes a security risk as it 2892 * is not possible to validate custom DH parameters. 2893 * If possible, it is recommended users should consider 2894 * preferring other methods of key exchange. 2895 * See dhm.h for more details. 2896 * 2897 */ 2898 #define MBEDTLS_DHM_C 2899 2900 /** 2901 * \def MBEDTLS_ECDH_C 2902 * 2903 * Enable the elliptic curve Diffie-Hellman library. 2904 * 2905 * Module: library/ecdh.c 2906 * Caller: library/ssl_cli.c 2907 * library/ssl_srv.c 2908 * 2909 * This module is used by the following key exchanges: 2910 * ECDHE-ECDSA, ECDHE-RSA, DHE-PSK 2911 * 2912 * Requires: MBEDTLS_ECP_C 2913 */ 2914 #define MBEDTLS_ECDH_C 2915 2916 /** 2917 * \def MBEDTLS_ECDSA_C 2918 * 2919 * Enable the elliptic curve DSA library. 2920 * 2921 * Module: library/ecdsa.c 2922 * Caller: 2923 * 2924 * This module is used by the following key exchanges: 2925 * ECDHE-ECDSA 2926 * 2927 * Requires: MBEDTLS_ECP_C, MBEDTLS_ASN1_WRITE_C, MBEDTLS_ASN1_PARSE_C, 2928 * and at least one MBEDTLS_ECP_DP_XXX_ENABLED for a 2929 * short Weierstrass curve. 2930 */ 2931 #define MBEDTLS_ECDSA_C 2932 2933 /** 2934 * \def MBEDTLS_ECJPAKE_C 2935 * 2936 * Enable the elliptic curve J-PAKE library. 2937 * 2938 * \warning This is currently experimental. EC J-PAKE support is based on the 2939 * Thread v1.0.0 specification; incompatible changes to the specification 2940 * might still happen. For this reason, this is disabled by default. 2941 * 2942 * Module: library/ecjpake.c 2943 * Caller: 2944 * 2945 * This module is used by the following key exchanges: 2946 * ECJPAKE 2947 * 2948 * Requires: MBEDTLS_ECP_C, MBEDTLS_MD_C 2949 */ 2950 //#define MBEDTLS_ECJPAKE_C 2951 2952 /** 2953 * \def MBEDTLS_ECP_C 2954 * 2955 * Enable the elliptic curve over GF(p) library. 2956 * 2957 * Module: library/ecp.c 2958 * Caller: library/ecdh.c 2959 * library/ecdsa.c 2960 * library/ecjpake.c 2961 * 2962 * Requires: MBEDTLS_BIGNUM_C and at least one MBEDTLS_ECP_DP_XXX_ENABLED 2963 */ 2964 #define MBEDTLS_ECP_C 2965 2966 /** 2967 * \def MBEDTLS_ENTROPY_C 2968 * 2969 * Enable the platform-specific entropy code. 2970 * 2971 * Module: library/entropy.c 2972 * Caller: 2973 * 2974 * Requires: MBEDTLS_SHA512_C or MBEDTLS_SHA256_C 2975 * 2976 * This module provides a generic entropy pool 2977 */ 2978 #define MBEDTLS_ENTROPY_C 2979 2980 /** 2981 * \def MBEDTLS_ERROR_C 2982 * 2983 * Enable error code to error string conversion. 2984 * 2985 * Module: library/error.c 2986 * Caller: 2987 * 2988 * This module enables mbedtls_strerror(). 2989 */ 2990 #define MBEDTLS_ERROR_C 2991 2992 /** 2993 * \def MBEDTLS_GCM_C 2994 * 2995 * Enable the Galois/Counter Mode (GCM). 2996 * 2997 * Module: library/gcm.c 2998 * 2999 * Requires: MBEDTLS_AES_C or MBEDTLS_CAMELLIA_C or MBEDTLS_ARIA_C 3000 * 3001 * This module enables the AES-GCM and CAMELLIA-GCM ciphersuites, if other 3002 * requisites are enabled as well. 3003 */ 3004 #define MBEDTLS_GCM_C 3005 3006 /** 3007 * \def MBEDTLS_HAVEGE_C 3008 * 3009 * Enable the HAVEGE random generator. 3010 * 3011 * Warning: the HAVEGE random generator is not suitable for virtualized 3012 * environments 3013 * 3014 * Warning: the HAVEGE random generator is dependent on timing and specific 3015 * processor traits. It is therefore not advised to use HAVEGE as 3016 * your applications primary random generator or primary entropy pool 3017 * input. As a secondary input to your entropy pool, it IS able add 3018 * the (limited) extra entropy it provides. 3019 * 3020 * Module: library/havege.c 3021 * Caller: 3022 * 3023 * Requires: MBEDTLS_TIMING_C 3024 * 3025 * Uncomment to enable the HAVEGE random generator. 3026 */ 3027 //#define MBEDTLS_HAVEGE_C 3028 3029 /** 3030 * \def MBEDTLS_HKDF_C 3031 * 3032 * Enable the HKDF algorithm (RFC 5869). 3033 * 3034 * Module: library/hkdf.c 3035 * Caller: 3036 * 3037 * Requires: MBEDTLS_MD_C 3038 * 3039 * This module adds support for the Hashed Message Authentication Code 3040 * (HMAC)-based key derivation function (HKDF). 3041 */ 3042 #define MBEDTLS_HKDF_C 3043 3044 /** 3045 * \def MBEDTLS_HMAC_DRBG_C 3046 * 3047 * Enable the HMAC_DRBG random generator. 3048 * 3049 * Module: library/hmac_drbg.c 3050 * Caller: 3051 * 3052 * Requires: MBEDTLS_MD_C 3053 * 3054 * Uncomment to enable the HMAC_DRBG random number generator. 3055 */ 3056 #define MBEDTLS_HMAC_DRBG_C 3057 3058 /** 3059 * \def MBEDTLS_NIST_KW_C 3060 * 3061 * Enable the Key Wrapping mode for 128-bit block ciphers, 3062 * as defined in NIST SP 800-38F. Only KW and KWP modes 3063 * are supported. At the moment, only AES is approved by NIST. 3064 * 3065 * Module: library/nist_kw.c 3066 * 3067 * Requires: MBEDTLS_AES_C and MBEDTLS_CIPHER_C 3068 */ 3069 //#define MBEDTLS_NIST_KW_C 3070 3071 /** 3072 * \def MBEDTLS_MD_C 3073 * 3074 * Enable the generic message digest layer. 3075 * 3076 * Module: library/md.c 3077 * Caller: 3078 * 3079 * Uncomment to enable generic message digest wrappers. 3080 */ 3081 #define MBEDTLS_MD_C 3082 3083 /** 3084 * \def MBEDTLS_MD2_C 3085 * 3086 * Enable the MD2 hash algorithm. 3087 * 3088 * Module: library/md2.c 3089 * Caller: 3090 * 3091 * Uncomment to enable support for (rare) MD2-signed X.509 certs. 3092 * 3093 * \warning MD2 is considered a weak message digest and its use constitutes a 3094 * security risk. If possible, we recommend avoiding dependencies on 3095 * it, and considering stronger message digests instead. 3096 * 3097 */ 3098 //#define MBEDTLS_MD2_C 3099 3100 /** 3101 * \def MBEDTLS_MD4_C 3102 * 3103 * Enable the MD4 hash algorithm. 3104 * 3105 * Module: library/md4.c 3106 * Caller: 3107 * 3108 * Uncomment to enable support for (rare) MD4-signed X.509 certs. 3109 * 3110 * \warning MD4 is considered a weak message digest and its use constitutes a 3111 * security risk. If possible, we recommend avoiding dependencies on 3112 * it, and considering stronger message digests instead. 3113 * 3114 */ 3115 //#define MBEDTLS_MD4_C 3116 3117 /** 3118 * \def MBEDTLS_MD5_C 3119 * 3120 * Enable the MD5 hash algorithm. 3121 * 3122 * Module: library/md5.c 3123 * Caller: library/md.c 3124 * library/pem.c 3125 * library/ssl_tls.c 3126 * 3127 * This module is required for SSL/TLS up to version 1.1, and for TLS 1.2 3128 * depending on the handshake parameters. Further, it is used for checking 3129 * MD5-signed certificates, and for PBKDF1 when decrypting PEM-encoded 3130 * encrypted keys. 3131 * 3132 * \warning MD5 is considered a weak message digest and its use constitutes a 3133 * security risk. If possible, we recommend avoiding dependencies on 3134 * it, and considering stronger message digests instead. 3135 * 3136 */ 3137 #define MBEDTLS_MD5_C 3138 3139 /** 3140 * \def MBEDTLS_MEMORY_BUFFER_ALLOC_C 3141 * 3142 * Enable the buffer allocator implementation that makes use of a (stack) 3143 * based buffer to 'allocate' dynamic memory. (replaces calloc() and free() 3144 * calls) 3145 * 3146 * Module: library/memory_buffer_alloc.c 3147 * 3148 * Requires: MBEDTLS_PLATFORM_C 3149 * MBEDTLS_PLATFORM_MEMORY (to use it within Mbed TLS) 3150 * 3151 * Enable this module to enable the buffer memory allocator. 3152 */ 3153 //#define MBEDTLS_MEMORY_BUFFER_ALLOC_C 3154 3155 /** 3156 * \def MBEDTLS_NET_C 3157 * 3158 * Enable the TCP and UDP over IPv6/IPv4 networking routines. 3159 * 3160 * \note This module only works on POSIX/Unix (including Linux, BSD and OS X) 3161 * and Windows. For other platforms, you'll want to disable it, and write your 3162 * own networking callbacks to be passed to \c mbedtls_ssl_set_bio(). 3163 * 3164 * \note See also our Knowledge Base article about porting to a new 3165 * environment: 3166 * https://mbed-tls.readthedocs.io/en/latest/kb/how-to/how-do-i-port-mbed-tls-to-a-new-environment-OS 3167 * 3168 * Module: library/net_sockets.c 3169 * 3170 * This module provides networking routines. 3171 */ 3172 #define MBEDTLS_NET_C 3173 3174 /** 3175 * \def MBEDTLS_OID_C 3176 * 3177 * Enable the OID database. 3178 * 3179 * Module: library/oid.c 3180 * Caller: library/asn1write.c 3181 * library/pkcs5.c 3182 * library/pkparse.c 3183 * library/pkwrite.c 3184 * library/rsa.c 3185 * library/x509.c 3186 * library/x509_create.c 3187 * library/x509_crl.c 3188 * library/x509_crt.c 3189 * library/x509_csr.c 3190 * library/x509write_crt.c 3191 * library/x509write_csr.c 3192 * 3193 * This modules translates between OIDs and internal values. 3194 */ 3195 #define MBEDTLS_OID_C 3196 3197 /** 3198 * \def MBEDTLS_PADLOCK_C 3199 * 3200 * Enable VIA Padlock support on x86. 3201 * 3202 * Module: library/padlock.c 3203 * Caller: library/aes.c 3204 * 3205 * Requires: MBEDTLS_HAVE_ASM 3206 * 3207 * This modules adds support for the VIA PadLock on x86. 3208 */ 3209 #define MBEDTLS_PADLOCK_C 3210 3211 /** 3212 * \def MBEDTLS_PEM_PARSE_C 3213 * 3214 * Enable PEM decoding / parsing. 3215 * 3216 * Module: library/pem.c 3217 * Caller: library/dhm.c 3218 * library/pkparse.c 3219 * library/x509_crl.c 3220 * library/x509_crt.c 3221 * library/x509_csr.c 3222 * 3223 * Requires: MBEDTLS_BASE64_C 3224 * 3225 * This modules adds support for decoding / parsing PEM files. 3226 */ 3227 #define MBEDTLS_PEM_PARSE_C 3228 3229 /** 3230 * \def MBEDTLS_PEM_WRITE_C 3231 * 3232 * Enable PEM encoding / writing. 3233 * 3234 * Module: library/pem.c 3235 * Caller: library/pkwrite.c 3236 * library/x509write_crt.c 3237 * library/x509write_csr.c 3238 * 3239 * Requires: MBEDTLS_BASE64_C 3240 * 3241 * This modules adds support for encoding / writing PEM files. 3242 */ 3243 #define MBEDTLS_PEM_WRITE_C 3244 3245 /** 3246 * \def MBEDTLS_PK_C 3247 * 3248 * Enable the generic public (asymmetric) key layer. 3249 * 3250 * Module: library/pk.c 3251 * Caller: library/ssl_tls.c 3252 * library/ssl_cli.c 3253 * library/ssl_srv.c 3254 * 3255 * Requires: MBEDTLS_RSA_C or MBEDTLS_ECP_C 3256 * 3257 * Uncomment to enable generic public key wrappers. 3258 */ 3259 #define MBEDTLS_PK_C 3260 3261 /** 3262 * \def MBEDTLS_PK_PARSE_C 3263 * 3264 * Enable the generic public (asymmetric) key parser. 3265 * 3266 * Module: library/pkparse.c 3267 * Caller: library/x509_crt.c 3268 * library/x509_csr.c 3269 * 3270 * Requires: MBEDTLS_PK_C 3271 * 3272 * Uncomment to enable generic public key parse functions. 3273 */ 3274 #define MBEDTLS_PK_PARSE_C 3275 3276 /** 3277 * \def MBEDTLS_PK_WRITE_C 3278 * 3279 * Enable the generic public (asymmetric) key writer. 3280 * 3281 * Module: library/pkwrite.c 3282 * Caller: library/x509write.c 3283 * 3284 * Requires: MBEDTLS_PK_C 3285 * 3286 * Uncomment to enable generic public key write functions. 3287 */ 3288 #define MBEDTLS_PK_WRITE_C 3289 3290 /** 3291 * \def MBEDTLS_PKCS5_C 3292 * 3293 * Enable PKCS#5 functions. 3294 * 3295 * Module: library/pkcs5.c 3296 * 3297 * Requires: MBEDTLS_MD_C 3298 * 3299 * This module adds support for the PKCS#5 functions. 3300 */ 3301 #define MBEDTLS_PKCS5_C 3302 3303 /** 3304 * \def MBEDTLS_PKCS11_C 3305 * 3306 * Enable wrapper for PKCS#11 smartcard support via the pkcs11-helper library. 3307 * 3308 * \deprecated This option is deprecated and will be removed in a future 3309 * version of Mbed TLS. 3310 * 3311 * Module: library/pkcs11.c 3312 * Caller: library/pk.c 3313 * 3314 * Requires: MBEDTLS_PK_C 3315 * 3316 * This module enables SSL/TLS PKCS #11 smartcard support. 3317 * Requires the presence of the PKCS#11 helper library (libpkcs11-helper) 3318 */ 3319 //#define MBEDTLS_PKCS11_C 3320 3321 /** 3322 * \def MBEDTLS_PKCS12_C 3323 * 3324 * Enable PKCS#12 PBE functions. 3325 * Adds algorithms for parsing PKCS#8 encrypted private keys 3326 * 3327 * Module: library/pkcs12.c 3328 * Caller: library/pkparse.c 3329 * 3330 * Requires: MBEDTLS_ASN1_PARSE_C, MBEDTLS_CIPHER_C, MBEDTLS_MD_C 3331 * Can use: MBEDTLS_ARC4_C 3332 * 3333 * This module enables PKCS#12 functions. 3334 */ 3335 #define MBEDTLS_PKCS12_C 3336 3337 /** 3338 * \def MBEDTLS_PLATFORM_C 3339 * 3340 * Enable the platform abstraction layer that allows you to re-assign 3341 * functions like calloc(), free(), snprintf(), printf(), fprintf(), exit(). 3342 * 3343 * Enabling MBEDTLS_PLATFORM_C enables to use of MBEDTLS_PLATFORM_XXX_ALT 3344 * or MBEDTLS_PLATFORM_XXX_MACRO directives, allowing the functions mentioned 3345 * above to be specified at runtime or compile time respectively. 3346 * 3347 * \note This abstraction layer must be enabled on Windows (including MSYS2) 3348 * as other module rely on it for a fixed snprintf implementation. 3349 * 3350 * Module: library/platform.c 3351 * Caller: Most other .c files 3352 * 3353 * This module enables abstraction of common (libc) functions. 3354 */ 3355 #define MBEDTLS_PLATFORM_C 3356 3357 /** 3358 * \def MBEDTLS_POLY1305_C 3359 * 3360 * Enable the Poly1305 MAC algorithm. 3361 * 3362 * Module: library/poly1305.c 3363 * Caller: library/chachapoly.c 3364 */ 3365 #define MBEDTLS_POLY1305_C 3366 3367 /** 3368 * \def MBEDTLS_PSA_CRYPTO_C 3369 * 3370 * Enable the Platform Security Architecture cryptography API. 3371 * 3372 * Module: library/psa_crypto.c 3373 * 3374 * Requires: either MBEDTLS_CTR_DRBG_C and MBEDTLS_ENTROPY_C, 3375 * or MBEDTLS_HMAC_DRBG_C and MBEDTLS_ENTROPY_C, 3376 * or MBEDTLS_PSA_CRYPTO_EXTERNAL_RNG. 3377 * 3378 */ 3379 #define MBEDTLS_PSA_CRYPTO_C 3380 3381 /** 3382 * \def MBEDTLS_PSA_CRYPTO_SE_C 3383 * 3384 * Enable secure element support in the Platform Security Architecture 3385 * cryptography API. 3386 * 3387 * \warning This feature is not yet suitable for production. It is provided 3388 * for API evaluation and testing purposes only. 3389 * 3390 * Module: library/psa_crypto_se.c 3391 * 3392 * Requires: MBEDTLS_PSA_CRYPTO_C, MBEDTLS_PSA_CRYPTO_STORAGE_C 3393 * 3394 */ 3395 //#define MBEDTLS_PSA_CRYPTO_SE_C 3396 3397 /** 3398 * \def MBEDTLS_PSA_CRYPTO_STORAGE_C 3399 * 3400 * Enable the Platform Security Architecture persistent key storage. 3401 * 3402 * Module: library/psa_crypto_storage.c 3403 * 3404 * Requires: MBEDTLS_PSA_CRYPTO_C, 3405 * either MBEDTLS_PSA_ITS_FILE_C or a native implementation of 3406 * the PSA ITS interface 3407 */ 3408 #define MBEDTLS_PSA_CRYPTO_STORAGE_C 3409 3410 /** 3411 * \def MBEDTLS_PSA_ITS_FILE_C 3412 * 3413 * Enable the emulation of the Platform Security Architecture 3414 * Internal Trusted Storage (PSA ITS) over files. 3415 * 3416 * Module: library/psa_its_file.c 3417 * 3418 * Requires: MBEDTLS_FS_IO 3419 */ 3420 #define MBEDTLS_PSA_ITS_FILE_C 3421 3422 /** 3423 * \def MBEDTLS_RIPEMD160_C 3424 * 3425 * Enable the RIPEMD-160 hash algorithm. 3426 * 3427 * Module: library/ripemd160.c 3428 * Caller: library/md.c 3429 * 3430 */ 3431 #define MBEDTLS_RIPEMD160_C 3432 3433 /** 3434 * \def MBEDTLS_RSA_C 3435 * 3436 * Enable the RSA public-key cryptosystem. 3437 * 3438 * Module: library/rsa.c 3439 * library/rsa_internal.c 3440 * Caller: library/ssl_cli.c 3441 * library/ssl_srv.c 3442 * library/ssl_tls.c 3443 * library/x509.c 3444 * 3445 * This module is used by the following key exchanges: 3446 * RSA, DHE-RSA, ECDHE-RSA, RSA-PSK 3447 * 3448 * Requires: MBEDTLS_BIGNUM_C, MBEDTLS_OID_C 3449 */ 3450 #define MBEDTLS_RSA_C 3451 3452 /** 3453 * \def MBEDTLS_SHA1_C 3454 * 3455 * Enable the SHA1 cryptographic hash algorithm. 3456 * 3457 * Module: library/sha1.c 3458 * Caller: library/md.c 3459 * library/ssl_cli.c 3460 * library/ssl_srv.c 3461 * library/ssl_tls.c 3462 * library/x509write_crt.c 3463 * 3464 * This module is required for SSL/TLS up to version 1.1, for TLS 1.2 3465 * depending on the handshake parameters, and for SHA1-signed certificates. 3466 * 3467 * \warning SHA-1 is considered a weak message digest and its use constitutes 3468 * a security risk. If possible, we recommend avoiding dependencies 3469 * on it, and considering stronger message digests instead. 3470 * 3471 */ 3472 #define MBEDTLS_SHA1_C 3473 3474 /** 3475 * \def MBEDTLS_SHA256_C 3476 * 3477 * Enable the SHA-224 and SHA-256 cryptographic hash algorithms. 3478 * 3479 * Module: library/sha256.c 3480 * Caller: library/entropy.c 3481 * library/md.c 3482 * library/ssl_cli.c 3483 * library/ssl_srv.c 3484 * library/ssl_tls.c 3485 * 3486 * This module adds support for SHA-224 and SHA-256. 3487 * This module is required for the SSL/TLS 1.2 PRF function. 3488 */ 3489 #define MBEDTLS_SHA256_C 3490 3491 /** 3492 * \def MBEDTLS_SHA512_C 3493 * 3494 * Enable the SHA-384 and SHA-512 cryptographic hash algorithms. 3495 * 3496 * Module: library/sha512.c 3497 * Caller: library/entropy.c 3498 * library/md.c 3499 * library/ssl_cli.c 3500 * library/ssl_srv.c 3501 * 3502 * This module adds support for SHA-384 and SHA-512. 3503 */ 3504 #define MBEDTLS_SHA512_C 3505 3506 /** 3507 * \def MBEDTLS_SSL_CACHE_C 3508 * 3509 * Enable simple SSL cache implementation. 3510 * 3511 * Module: library/ssl_cache.c 3512 * Caller: 3513 * 3514 * Requires: MBEDTLS_SSL_CACHE_C 3515 */ 3516 #define MBEDTLS_SSL_CACHE_C 3517 3518 /** 3519 * \def MBEDTLS_SSL_COOKIE_C 3520 * 3521 * Enable basic implementation of DTLS cookies for hello verification. 3522 * 3523 * Module: library/ssl_cookie.c 3524 * Caller: 3525 */ 3526 #define MBEDTLS_SSL_COOKIE_C 3527 3528 /** 3529 * \def MBEDTLS_SSL_TICKET_C 3530 * 3531 * Enable an implementation of TLS server-side callbacks for session tickets. 3532 * 3533 * Module: library/ssl_ticket.c 3534 * Caller: 3535 * 3536 * Requires: MBEDTLS_CIPHER_C && 3537 * ( MBEDTLS_GCM_C || MBEDTLS_CCM_C || MBEDTLS_CHACHAPOLY_C ) 3538 */ 3539 #define MBEDTLS_SSL_TICKET_C 3540 3541 /** 3542 * \def MBEDTLS_SSL_CLI_C 3543 * 3544 * Enable the SSL/TLS client code. 3545 * 3546 * Module: library/ssl_cli.c 3547 * Caller: 3548 * 3549 * Requires: MBEDTLS_SSL_TLS_C 3550 * 3551 * This module is required for SSL/TLS client support. 3552 */ 3553 #define MBEDTLS_SSL_CLI_C 3554 3555 /** 3556 * \def MBEDTLS_SSL_SRV_C 3557 * 3558 * Enable the SSL/TLS server code. 3559 * 3560 * Module: library/ssl_srv.c 3561 * Caller: 3562 * 3563 * Requires: MBEDTLS_SSL_TLS_C 3564 * 3565 * This module is required for SSL/TLS server support. 3566 */ 3567 #define MBEDTLS_SSL_SRV_C 3568 3569 /** 3570 * \def MBEDTLS_SSL_TLS_C 3571 * 3572 * Enable the generic SSL/TLS code. 3573 * 3574 * Module: library/ssl_tls.c 3575 * Caller: library/ssl_cli.c 3576 * library/ssl_srv.c 3577 * 3578 * Requires: MBEDTLS_CIPHER_C, MBEDTLS_MD_C 3579 * and at least one of the MBEDTLS_SSL_PROTO_XXX defines 3580 * 3581 * This module is required for SSL/TLS. 3582 */ 3583 #define MBEDTLS_SSL_TLS_C 3584 3585 /** 3586 * \def MBEDTLS_THREADING_C 3587 * 3588 * Enable the threading abstraction layer. 3589 * By default Mbed TLS assumes it is used in a non-threaded environment or that 3590 * contexts are not shared between threads. If you do intend to use contexts 3591 * between threads, you will need to enable this layer to prevent race 3592 * conditions. See also our Knowledge Base article about threading: 3593 * https://mbed-tls.readthedocs.io/en/latest/kb/development/thread-safety-and-multi-threading 3594 * 3595 * Module: library/threading.c 3596 * 3597 * This allows different threading implementations (self-implemented or 3598 * provided). 3599 * 3600 * You will have to enable either MBEDTLS_THREADING_ALT or 3601 * MBEDTLS_THREADING_PTHREAD. 3602 * 3603 * Enable this layer to allow use of mutexes within Mbed TLS 3604 */ 3605 //#define MBEDTLS_THREADING_C 3606 3607 /** 3608 * \def MBEDTLS_TIMING_C 3609 * 3610 * Enable the semi-portable timing interface. 3611 * 3612 * \note The provided implementation only works on POSIX/Unix (including Linux, 3613 * BSD and OS X) and Windows. On other platforms, you can either disable that 3614 * module and provide your own implementations of the callbacks needed by 3615 * \c mbedtls_ssl_set_timer_cb() for DTLS, or leave it enabled and provide 3616 * your own implementation of the whole module by setting 3617 * \c MBEDTLS_TIMING_ALT in the current file. 3618 * 3619 * \note The timing module will include time.h on suitable platforms 3620 * regardless of the setting of MBEDTLS_HAVE_TIME, unless 3621 * MBEDTLS_TIMING_ALT is used. See timing.c for more information. 3622 * 3623 * \note See also our Knowledge Base article about porting to a new 3624 * environment: 3625 * https://mbed-tls.readthedocs.io/en/latest/kb/how-to/how-do-i-port-mbed-tls-to-a-new-environment-OS 3626 * 3627 * Module: library/timing.c 3628 * Caller: library/havege.c 3629 * 3630 * This module is used by the HAVEGE random number generator. 3631 */ 3632 #define MBEDTLS_TIMING_C 3633 3634 /** 3635 * \def MBEDTLS_VERSION_C 3636 * 3637 * Enable run-time version information. 3638 * 3639 * Module: library/version.c 3640 * 3641 * This module provides run-time version information. 3642 */ 3643 #define MBEDTLS_VERSION_C 3644 3645 /** 3646 * \def MBEDTLS_X509_USE_C 3647 * 3648 * Enable X.509 core for using certificates. 3649 * 3650 * Module: library/x509.c 3651 * Caller: library/x509_crl.c 3652 * library/x509_crt.c 3653 * library/x509_csr.c 3654 * 3655 * Requires: MBEDTLS_ASN1_PARSE_C, MBEDTLS_BIGNUM_C, MBEDTLS_OID_C, 3656 * MBEDTLS_PK_PARSE_C 3657 * 3658 * This module is required for the X.509 parsing modules. 3659 */ 3660 #define MBEDTLS_X509_USE_C 3661 3662 /** 3663 * \def MBEDTLS_X509_CRT_PARSE_C 3664 * 3665 * Enable X.509 certificate parsing. 3666 * 3667 * Module: library/x509_crt.c 3668 * Caller: library/ssl_cli.c 3669 * library/ssl_srv.c 3670 * library/ssl_tls.c 3671 * 3672 * Requires: MBEDTLS_X509_USE_C 3673 * 3674 * This module is required for X.509 certificate parsing. 3675 */ 3676 #define MBEDTLS_X509_CRT_PARSE_C 3677 3678 /** 3679 * \def MBEDTLS_X509_CRL_PARSE_C 3680 * 3681 * Enable X.509 CRL parsing. 3682 * 3683 * Module: library/x509_crl.c 3684 * Caller: library/x509_crt.c 3685 * 3686 * Requires: MBEDTLS_X509_USE_C 3687 * 3688 * This module is required for X.509 CRL parsing. 3689 */ 3690 #define MBEDTLS_X509_CRL_PARSE_C 3691 3692 /** 3693 * \def MBEDTLS_X509_CSR_PARSE_C 3694 * 3695 * Enable X.509 Certificate Signing Request (CSR) parsing. 3696 * 3697 * Module: library/x509_csr.c 3698 * Caller: library/x509_crt_write.c 3699 * 3700 * Requires: MBEDTLS_X509_USE_C 3701 * 3702 * This module is used for reading X.509 certificate request. 3703 */ 3704 #define MBEDTLS_X509_CSR_PARSE_C 3705 3706 /** 3707 * \def MBEDTLS_X509_CREATE_C 3708 * 3709 * Enable X.509 core for creating certificates. 3710 * 3711 * Module: library/x509_create.c 3712 * 3713 * Requires: MBEDTLS_BIGNUM_C, MBEDTLS_OID_C, MBEDTLS_PK_WRITE_C 3714 * 3715 * This module is the basis for creating X.509 certificates and CSRs. 3716 */ 3717 #define MBEDTLS_X509_CREATE_C 3718 3719 /** 3720 * \def MBEDTLS_X509_CRT_WRITE_C 3721 * 3722 * Enable creating X.509 certificates. 3723 * 3724 * Module: library/x509_crt_write.c 3725 * 3726 * Requires: MBEDTLS_X509_CREATE_C 3727 * 3728 * This module is required for X.509 certificate creation. 3729 */ 3730 #define MBEDTLS_X509_CRT_WRITE_C 3731 3732 /** 3733 * \def MBEDTLS_X509_CSR_WRITE_C 3734 * 3735 * Enable creating X.509 Certificate Signing Requests (CSR). 3736 * 3737 * Module: library/x509_csr_write.c 3738 * 3739 * Requires: MBEDTLS_X509_CREATE_C 3740 * 3741 * This module is required for X.509 certificate request writing. 3742 */ 3743 #define MBEDTLS_X509_CSR_WRITE_C 3744 3745 /** 3746 * \def MBEDTLS_XTEA_C 3747 * 3748 * Enable the XTEA block cipher. 3749 * 3750 * Module: library/xtea.c 3751 * Caller: 3752 */ 3753 #define MBEDTLS_XTEA_C 3754 3755 /** \} name SECTION: Mbed TLS modules */ 3756 3757 /** 3758 * \name SECTION: General configuration options 3759 * 3760 * This section contains Mbed TLS build settings that are not associated 3761 * with a particular module. 3762 * 3763 * \{ 3764 */ 3765 3766 /** 3767 * \def MBEDTLS_CONFIG_FILE 3768 * 3769 * If defined, this is a header which will be included instead of 3770 * `"mbedtls/config.h"`. 3771 * This header file specifies the compile-time configuration of Mbed TLS. 3772 * Unlike other configuration options, this one must be defined on the 3773 * compiler command line: a definition in `config.h` would have no effect. 3774 * 3775 * This macro is expanded after an <tt>\#include</tt> directive. This is a popular but 3776 * non-standard feature of the C language, so this feature is only available 3777 * with compilers that perform macro expansion on an <tt>\#include</tt> line. 3778 * 3779 * The value of this symbol is typically a path in double quotes, either 3780 * absolute or relative to a directory on the include search path. 3781 */ 3782 //#define MBEDTLS_CONFIG_FILE "mbedtls/config.h" 3783 3784 /** 3785 * \def MBEDTLS_USER_CONFIG_FILE 3786 * 3787 * If defined, this is a header which will be included after 3788 * `"mbedtls/config.h"` or #MBEDTLS_CONFIG_FILE. 3789 * This allows you to modify the default configuration, including the ability 3790 * to undefine options that are enabled by default. 3791 * 3792 * This macro is expanded after an <tt>\#include</tt> directive. This is a popular but 3793 * non-standard feature of the C language, so this feature is only available 3794 * with compilers that perform macro expansion on an <tt>\#include</tt> line. 3795 * 3796 * The value of this symbol is typically a path in double quotes, either 3797 * absolute or relative to a directory on the include search path. 3798 */ 3799 //#define MBEDTLS_USER_CONFIG_FILE "/dev/null" 3800 3801 /** 3802 * \def MBEDTLS_PSA_CRYPTO_CONFIG_FILE 3803 * 3804 * If defined, this is a header which will be included instead of 3805 * `"psa/crypto_config.h"`. 3806 * This header file specifies which cryptographic mechanisms are available 3807 * through the PSA API when #MBEDTLS_PSA_CRYPTO_CONFIG is enabled, and 3808 * is not used when #MBEDTLS_PSA_CRYPTO_CONFIG is disabled. 3809 * 3810 * This macro is expanded after an <tt>\#include</tt> directive. This is a popular but 3811 * non-standard feature of the C language, so this feature is only available 3812 * with compilers that perform macro expansion on an <tt>\#include</tt> line. 3813 * 3814 * The value of this symbol is typically a path in double quotes, either 3815 * absolute or relative to a directory on the include search path. 3816 */ 3817 //#define MBEDTLS_PSA_CRYPTO_CONFIG_FILE "psa/crypto_config.h" 3818 3819 /** 3820 * \def MBEDTLS_PSA_CRYPTO_USER_CONFIG_FILE 3821 * 3822 * If defined, this is a header which will be included after 3823 * `"psa/crypto_config.h"` or #MBEDTLS_PSA_CRYPTO_CONFIG_FILE. 3824 * This allows you to modify the default configuration, including the ability 3825 * to undefine options that are enabled by default. 3826 * 3827 * This macro is expanded after an <tt>\#include</tt> directive. This is a popular but 3828 * non-standard feature of the C language, so this feature is only available 3829 * with compilers that perform macro expansion on an <tt>\#include</tt> line. 3830 * 3831 * The value of this symbol is typically a path in double quotes, either 3832 * absolute or relative to a directory on the include search path. 3833 */ 3834 //#define MBEDTLS_PSA_CRYPTO_USER_CONFIG_FILE "/dev/null" 3835 3836 /** \} name SECTION: General configuration options */ 3837 3838 /** 3839 * \name SECTION: Module configuration options 3840 * 3841 * This section allows for the setting of module specific sizes and 3842 * configuration options. The default values are already present in the 3843 * relevant header files and should suffice for the regular use cases. 3844 * 3845 * Our advice is to enable options and change their values here 3846 * only if you have a good reason and know the consequences. 3847 * \{ 3848 */ 3849 /* The Doxygen documentation here is used when a user comments out a 3850 * setting and runs doxygen themselves. On the other hand, when we typeset 3851 * the full documentation including disabled settings, the documentation 3852 * in specific modules' header files is used if present. When editing this 3853 * file, make sure that each option is documented in exactly one place, 3854 * plus optionally a same-line Doxygen comment here if there is a Doxygen 3855 * comment in the specific module. */ 3856 3857 /* MPI / BIGNUM options */ 3858 //#define MBEDTLS_MPI_WINDOW_SIZE 2 /**< Maximum window size used. */ 3859 //#define MBEDTLS_MPI_MAX_SIZE 1024 /**< Maximum number of bytes for usable MPIs. */ 3860 3861 /* CTR_DRBG options */ 3862 //#define MBEDTLS_CTR_DRBG_ENTROPY_LEN 48 /**< Amount of entropy used per seed by default (48 with SHA-512, 32 with SHA-256) */ 3863 //#define MBEDTLS_CTR_DRBG_RESEED_INTERVAL 10000 /**< Interval before reseed is performed by default */ 3864 //#define MBEDTLS_CTR_DRBG_MAX_INPUT 256 /**< Maximum number of additional input bytes */ 3865 //#define MBEDTLS_CTR_DRBG_MAX_REQUEST 1024 /**< Maximum number of requested bytes per call */ 3866 //#define MBEDTLS_CTR_DRBG_MAX_SEED_INPUT 384 /**< Maximum size of (re)seed buffer */ 3867 3868 /* HMAC_DRBG options */ 3869 //#define MBEDTLS_HMAC_DRBG_RESEED_INTERVAL 10000 /**< Interval before reseed is performed by default */ 3870 //#define MBEDTLS_HMAC_DRBG_MAX_INPUT 256 /**< Maximum number of additional input bytes */ 3871 //#define MBEDTLS_HMAC_DRBG_MAX_REQUEST 1024 /**< Maximum number of requested bytes per call */ 3872 //#define MBEDTLS_HMAC_DRBG_MAX_SEED_INPUT 384 /**< Maximum size of (re)seed buffer */ 3873 3874 /* ECP options */ 3875 //#define MBEDTLS_ECP_MAX_BITS 521 /**< Maximum bit size of groups. Normally determined automatically from the configured curves. */ 3876 //#define MBEDTLS_ECP_WINDOW_SIZE 4 /**< Maximum window size used */ 3877 //#define MBEDTLS_ECP_FIXED_POINT_OPTIM 1 /**< Enable fixed-point speed-up */ 3878 3879 /* Entropy options */ 3880 //#define MBEDTLS_ENTROPY_MAX_SOURCES 20 /**< Maximum number of sources supported */ 3881 //#define MBEDTLS_ENTROPY_MAX_GATHER 128 /**< Maximum amount requested from entropy sources */ 3882 //#define MBEDTLS_ENTROPY_MIN_HARDWARE 32 /**< Default minimum number of bytes required for the hardware entropy source mbedtls_hardware_poll() before entropy is released */ 3883 3884 /* Memory buffer allocator options */ 3885 //#define MBEDTLS_MEMORY_ALIGN_MULTIPLE 4 /**< Align on multiples of this value */ 3886 3887 /* Platform options */ 3888 //#define MBEDTLS_PLATFORM_STD_MEM_HDR <stdlib.h> /**< Header to include if MBEDTLS_PLATFORM_NO_STD_FUNCTIONS is defined. Don't define if no header is needed. */ 3889 3890 /** \def MBEDTLS_PLATFORM_STD_CALLOC 3891 * 3892 * Default allocator to use, can be undefined. 3893 * It must initialize the allocated buffer memory to zeroes. 3894 * The size of the buffer is the product of the two parameters. 3895 * The calloc function returns either a null pointer or a pointer to the allocated space. 3896 * If the product is 0, the function may either return NULL or a valid pointer to an array of size 0 which is a valid input to the deallocation function. 3897 * An uninitialized #MBEDTLS_PLATFORM_STD_CALLOC always fails, returning a null pointer. 3898 * See the description of #MBEDTLS_PLATFORM_MEMORY for more details. 3899 * The corresponding deallocation function is #MBEDTLS_PLATFORM_STD_FREE. 3900 */ 3901 //#define MBEDTLS_PLATFORM_STD_CALLOC calloc 3902 3903 /** \def MBEDTLS_PLATFORM_STD_FREE 3904 * 3905 * Default free to use, can be undefined. 3906 * NULL is a valid parameter, and the function must do nothing. 3907 * A non-null parameter will always be a pointer previously returned by #MBEDTLS_PLATFORM_STD_CALLOC and not yet freed. 3908 * An uninitialized #MBEDTLS_PLATFORM_STD_FREE does not do anything. 3909 * See the description of #MBEDTLS_PLATFORM_MEMORY for more details (same principles as for MBEDTLS_PLATFORM_STD_CALLOC apply). 3910 */ 3911 //#define MBEDTLS_PLATFORM_STD_FREE free 3912 //#define MBEDTLS_PLATFORM_STD_EXIT exit /**< Default exit to use, can be undefined */ 3913 //#define MBEDTLS_PLATFORM_STD_TIME time /**< Default time to use, can be undefined. MBEDTLS_HAVE_TIME must be enabled */ 3914 //#define MBEDTLS_PLATFORM_STD_FPRINTF fprintf /**< Default fprintf to use, can be undefined */ 3915 //#define MBEDTLS_PLATFORM_STD_PRINTF printf /**< Default printf to use, can be undefined */ 3916 /* Note: your snprintf must correctly zero-terminate the buffer! */ 3917 //#define MBEDTLS_PLATFORM_STD_SNPRINTF snprintf /**< Default snprintf to use, can be undefined */ 3918 //#define MBEDTLS_PLATFORM_STD_EXIT_SUCCESS 0 /**< Default exit value to use, can be undefined */ 3919 //#define MBEDTLS_PLATFORM_STD_EXIT_FAILURE 1 /**< Default exit value to use, can be undefined */ 3920 //#define MBEDTLS_PLATFORM_STD_NV_SEED_READ mbedtls_platform_std_nv_seed_read /**< Default nv_seed_read function to use, can be undefined */ 3921 //#define MBEDTLS_PLATFORM_STD_NV_SEED_WRITE mbedtls_platform_std_nv_seed_write /**< Default nv_seed_write function to use, can be undefined */ 3922 //#define MBEDTLS_PLATFORM_STD_NV_SEED_FILE "seedfile" /**< Seed file to read/write with default implementation */ 3923 3924 /* To use the following function macros, MBEDTLS_PLATFORM_C must be enabled. */ 3925 /* MBEDTLS_PLATFORM_XXX_MACRO and MBEDTLS_PLATFORM_XXX_ALT cannot both be defined */ 3926 //#define MBEDTLS_PLATFORM_CALLOC_MACRO calloc /**< Default allocator macro to use, can be undefined. See MBEDTLS_PLATFORM_STD_CALLOC for requirements. */ 3927 //#define MBEDTLS_PLATFORM_FREE_MACRO free /**< Default free macro to use, can be undefined. See MBEDTLS_PLATFORM_STD_FREE for requirements. */ 3928 //#define MBEDTLS_PLATFORM_EXIT_MACRO exit /**< Default exit macro to use, can be undefined */ 3929 //#define MBEDTLS_PLATFORM_TIME_MACRO time /**< Default time macro to use, can be undefined. MBEDTLS_HAVE_TIME must be enabled */ 3930 //#define MBEDTLS_PLATFORM_TIME_TYPE_MACRO time_t /**< Default time macro to use, can be undefined. MBEDTLS_HAVE_TIME must be enabled */ 3931 //#define MBEDTLS_PLATFORM_FPRINTF_MACRO fprintf /**< Default fprintf macro to use, can be undefined */ 3932 //#define MBEDTLS_PLATFORM_PRINTF_MACRO printf /**< Default printf macro to use, can be undefined */ 3933 /* Note: your snprintf must correctly zero-terminate the buffer! */ 3934 //#define MBEDTLS_PLATFORM_SNPRINTF_MACRO snprintf /**< Default snprintf macro to use, can be undefined */ 3935 //#define MBEDTLS_PLATFORM_VSNPRINTF_MACRO vsnprintf /**< Default vsnprintf macro to use, can be undefined */ 3936 //#define MBEDTLS_PLATFORM_NV_SEED_READ_MACRO mbedtls_platform_std_nv_seed_read /**< Default nv_seed_read function to use, can be undefined */ 3937 //#define MBEDTLS_PLATFORM_NV_SEED_WRITE_MACRO mbedtls_platform_std_nv_seed_write /**< Default nv_seed_write function to use, can be undefined */ 3938 3939 /** 3940 * \brief This macro is invoked by the library when an invalid parameter 3941 * is detected that is only checked with #MBEDTLS_CHECK_PARAMS 3942 * (see the documentation of that option for context). 3943 * 3944 * When you leave this undefined here, the library provides 3945 * a default definition. If the macro #MBEDTLS_CHECK_PARAMS_ASSERT 3946 * is defined, the default definition is `assert(cond)`, 3947 * otherwise the default definition calls a function 3948 * mbedtls_param_failed(). This function is declared in 3949 * `platform_util.h` for the benefit of the library, but 3950 * you need to define in your application. 3951 * 3952 * When you define this here, this replaces the default 3953 * definition in platform_util.h (which no longer declares the 3954 * function mbedtls_param_failed()) and it is your responsibility 3955 * to make sure this macro expands to something suitable (in 3956 * particular, that all the necessary declarations are visible 3957 * from within the library - you can ensure that by providing 3958 * them in this file next to the macro definition). 3959 * If you define this macro to call `assert`, also define 3960 * #MBEDTLS_CHECK_PARAMS_ASSERT so that library source files 3961 * include `<assert.h>`. 3962 * 3963 * Note that you may define this macro to expand to nothing, in 3964 * which case you don't have to worry about declarations or 3965 * definitions. However, you will then be notified about invalid 3966 * parameters only in non-void functions, and void function will 3967 * just silently return early on invalid parameters, which 3968 * partially negates the benefits of enabling 3969 * #MBEDTLS_CHECK_PARAMS in the first place, so is discouraged. 3970 * 3971 * \param cond The expression that should evaluate to true, but doesn't. 3972 */ 3973 //#define MBEDTLS_PARAM_FAILED( cond ) assert( cond ) 3974 3975 /** \def MBEDTLS_CHECK_RETURN 3976 * 3977 * This macro is used at the beginning of the declaration of a function 3978 * to indicate that its return value should be checked. It should 3979 * instruct the compiler to emit a warning or an error if the function 3980 * is called without checking its return value. 3981 * 3982 * There is a default implementation for popular compilers in platform_util.h. 3983 * You can override the default implementation by defining your own here. 3984 * 3985 * If the implementation here is empty, this will effectively disable the 3986 * checking of functions' return values. 3987 */ 3988 //#define MBEDTLS_CHECK_RETURN __attribute__((__warn_unused_result__)) 3989 3990 /** \def MBEDTLS_IGNORE_RETURN 3991 * 3992 * This macro requires one argument, which should be a C function call. 3993 * If that function call would cause a #MBEDTLS_CHECK_RETURN warning, this 3994 * warning is suppressed. 3995 */ 3996 //#define MBEDTLS_IGNORE_RETURN( result ) ((void) !(result)) 3997 3998 /* PSA options */ 3999 /** 4000 * Use HMAC_DRBG with the specified hash algorithm for HMAC_DRBG for the 4001 * PSA crypto subsystem. 4002 * 4003 * If this option is unset: 4004 * - If CTR_DRBG is available, the PSA subsystem uses it rather than HMAC_DRBG. 4005 * - Otherwise, the PSA subsystem uses HMAC_DRBG with either 4006 * #MBEDTLS_MD_SHA512 or #MBEDTLS_MD_SHA256 based on availability and 4007 * on unspecified heuristics. 4008 */ 4009 //#define MBEDTLS_PSA_HMAC_DRBG_MD_TYPE MBEDTLS_MD_SHA256 4010 4011 /** \def MBEDTLS_PSA_KEY_SLOT_COUNT 4012 * Restrict the PSA library to supporting a maximum amount of simultaneously 4013 * loaded keys. A loaded key is a key stored by the PSA Crypto core as a 4014 * volatile key, or a persistent key which is loaded temporarily by the 4015 * library as part of a crypto operation in flight. 4016 * 4017 * If this option is unset, the library will fall back to a default value of 4018 * 32 keys. 4019 */ 4020 //#define MBEDTLS_PSA_KEY_SLOT_COUNT 32 4021 4022 /* SSL Cache options */ 4023 //#define MBEDTLS_SSL_CACHE_DEFAULT_TIMEOUT 86400 /**< 1 day */ 4024 //#define MBEDTLS_SSL_CACHE_DEFAULT_MAX_ENTRIES 50 /**< Maximum entries in cache */ 4025 4026 /* SSL options */ 4027 4028 /** \def MBEDTLS_SSL_MAX_CONTENT_LEN 4029 * 4030 * Maximum length (in bytes) of incoming and outgoing plaintext fragments. 4031 * 4032 * This determines the size of both the incoming and outgoing TLS I/O buffers 4033 * in such a way that both are capable of holding the specified amount of 4034 * plaintext data, regardless of the protection mechanism used. 4035 * 4036 * To configure incoming and outgoing I/O buffers separately, use 4037 * #MBEDTLS_SSL_IN_CONTENT_LEN and #MBEDTLS_SSL_OUT_CONTENT_LEN, 4038 * which overwrite the value set by this option. 4039 * 4040 * \note When using a value less than the default of 16KB on the client, it is 4041 * recommended to use the Maximum Fragment Length (MFL) extension to 4042 * inform the server about this limitation. On the server, there 4043 * is no supported, standardized way of informing the client about 4044 * restriction on the maximum size of incoming messages, and unless 4045 * the limitation has been communicated by other means, it is recommended 4046 * to only change the outgoing buffer size #MBEDTLS_SSL_OUT_CONTENT_LEN 4047 * while keeping the default value of 16KB for the incoming buffer. 4048 * 4049 * Uncomment to set the maximum plaintext size of both 4050 * incoming and outgoing I/O buffers. 4051 */ 4052 //#define MBEDTLS_SSL_MAX_CONTENT_LEN 16384 4053 4054 /** \def MBEDTLS_SSL_IN_CONTENT_LEN 4055 * 4056 * Maximum length (in bytes) of incoming plaintext fragments. 4057 * 4058 * This determines the size of the incoming TLS I/O buffer in such a way 4059 * that it is capable of holding the specified amount of plaintext data, 4060 * regardless of the protection mechanism used. 4061 * 4062 * If this option is undefined, it inherits its value from 4063 * #MBEDTLS_SSL_MAX_CONTENT_LEN. 4064 * 4065 * \note When using a value less than the default of 16KB on the client, it is 4066 * recommended to use the Maximum Fragment Length (MFL) extension to 4067 * inform the server about this limitation. On the server, there 4068 * is no supported, standardized way of informing the client about 4069 * restriction on the maximum size of incoming messages, and unless 4070 * the limitation has been communicated by other means, it is recommended 4071 * to only change the outgoing buffer size #MBEDTLS_SSL_OUT_CONTENT_LEN 4072 * while keeping the default value of 16KB for the incoming buffer. 4073 * 4074 * Uncomment to set the maximum plaintext size of the incoming I/O buffer 4075 * independently of the outgoing I/O buffer. 4076 */ 4077 //#define MBEDTLS_SSL_IN_CONTENT_LEN 16384 4078 4079 /** \def MBEDTLS_SSL_CID_IN_LEN_MAX 4080 * 4081 * The maximum length of CIDs used for incoming DTLS messages. 4082 * 4083 */ 4084 //#define MBEDTLS_SSL_CID_IN_LEN_MAX 32 4085 4086 /** \def MBEDTLS_SSL_CID_OUT_LEN_MAX 4087 * 4088 * The maximum length of CIDs used for outgoing DTLS messages. 4089 * 4090 */ 4091 //#define MBEDTLS_SSL_CID_OUT_LEN_MAX 32 4092 4093 /** \def MBEDTLS_SSL_CID_PADDING_GRANULARITY 4094 * 4095 * This option controls the use of record plaintext padding 4096 * when using the Connection ID extension in DTLS 1.2. 4097 * 4098 * The padding will always be chosen so that the length of the 4099 * padded plaintext is a multiple of the value of this option. 4100 * 4101 * Note: A value of \c 1 means that no padding will be used 4102 * for outgoing records. 4103 * 4104 * Note: On systems lacking division instructions, 4105 * a power of two should be preferred. 4106 * 4107 */ 4108 //#define MBEDTLS_SSL_CID_PADDING_GRANULARITY 16 4109 4110 /** \def MBEDTLS_SSL_TLS1_3_PADDING_GRANULARITY 4111 * 4112 * This option controls the use of record plaintext padding 4113 * in TLS 1.3. 4114 * 4115 * The padding will always be chosen so that the length of the 4116 * padded plaintext is a multiple of the value of this option. 4117 * 4118 * Note: A value of \c 1 means that no padding will be used 4119 * for outgoing records. 4120 * 4121 * Note: On systems lacking division instructions, 4122 * a power of two should be preferred. 4123 */ 4124 //#define MBEDTLS_SSL_TLS1_3_PADDING_GRANULARITY 1 4125 4126 /** \def MBEDTLS_SSL_OUT_CONTENT_LEN 4127 * 4128 * Maximum length (in bytes) of outgoing plaintext fragments. 4129 * 4130 * This determines the size of the outgoing TLS I/O buffer in such a way 4131 * that it is capable of holding the specified amount of plaintext data, 4132 * regardless of the protection mechanism used. 4133 * 4134 * If this option undefined, it inherits its value from 4135 * #MBEDTLS_SSL_MAX_CONTENT_LEN. 4136 * 4137 * It is possible to save RAM by setting a smaller outward buffer, while keeping 4138 * the default inward 16384 byte buffer to conform to the TLS specification. 4139 * 4140 * The minimum required outward buffer size is determined by the handshake 4141 * protocol's usage. Handshaking will fail if the outward buffer is too small. 4142 * The specific size requirement depends on the configured ciphers and any 4143 * certificate data which is sent during the handshake. 4144 * 4145 * Uncomment to set the maximum plaintext size of the outgoing I/O buffer 4146 * independently of the incoming I/O buffer. 4147 */ 4148 //#define MBEDTLS_SSL_OUT_CONTENT_LEN 16384 4149 4150 /** \def MBEDTLS_SSL_DTLS_MAX_BUFFERING 4151 * 4152 * Maximum number of heap-allocated bytes for the purpose of 4153 * DTLS handshake message reassembly and future message buffering. 4154 * 4155 * This should be at least 9/8 * MBEDTLS_SSL_IN_CONTENT_LEN 4156 * to account for a reassembled handshake message of maximum size, 4157 * together with its reassembly bitmap. 4158 * 4159 * A value of 2 * MBEDTLS_SSL_IN_CONTENT_LEN (32768 by default) 4160 * should be sufficient for all practical situations as it allows 4161 * to reassembly a large handshake message (such as a certificate) 4162 * while buffering multiple smaller handshake messages. 4163 * 4164 */ 4165 //#define MBEDTLS_SSL_DTLS_MAX_BUFFERING 32768 4166 4167 //#define MBEDTLS_SSL_DEFAULT_TICKET_LIFETIME 86400 /**< Lifetime of session tickets (if enabled) */ 4168 //#define MBEDTLS_PSK_MAX_LEN 32 /**< Max size of TLS pre-shared keys, in bytes (default 256 bits) */ 4169 //#define MBEDTLS_SSL_COOKIE_TIMEOUT 60 /**< Default expiration delay of DTLS cookies, in seconds if HAVE_TIME, or in number of cookies issued */ 4170 4171 /** \def MBEDTLS_TLS_EXT_CID 4172 * 4173 * At the time of writing, the CID extension has not been assigned its 4174 * final value. Set this configuration option to make Mbed TLS use a 4175 * different value. 4176 * 4177 * A future minor revision of Mbed TLS may change the default value of 4178 * this option to match evolving standards and usage. 4179 */ 4180 //#define MBEDTLS_TLS_EXT_CID 254 4181 4182 /** 4183 * Complete list of ciphersuites to use, in order of preference. 4184 * 4185 * \warning No dependency checking is done on that field! This option can only 4186 * be used to restrict the set of available ciphersuites. It is your 4187 * responsibility to make sure the needed modules are active. 4188 * 4189 * Use this to save a few hundred bytes of ROM (default ordering of all 4190 * available ciphersuites) and a few to a few hundred bytes of RAM. 4191 * 4192 * The value below is only an example, not the default. 4193 */ 4194 //#define MBEDTLS_SSL_CIPHERSUITES MBEDTLS_TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384,MBEDTLS_TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256 4195 4196 /* X509 options */ 4197 //#define MBEDTLS_X509_MAX_INTERMEDIATE_CA 8 /**< Maximum number of intermediate CAs in a verification chain. */ 4198 //#define MBEDTLS_X509_MAX_FILE_PATH_LEN 512 /**< Maximum length of a path/filename string in bytes including the null terminator character ('\0'). */ 4199 4200 /** \} name SECTION: Module configuration options */ 4201 4202 /* Target and application specific configurations 4203 * 4204 * Allow user to override any previous default. 4205 * 4206 */ 4207 #if defined(MBEDTLS_USER_CONFIG_FILE) 4208 #include MBEDTLS_USER_CONFIG_FILE 4209 #endif 4210 4211 #if defined(MBEDTLS_PSA_CRYPTO_CONFIG) 4212 #include "mbedtls/config_psa.h" 4213 #endif 4214 4215 #include "mbedtls/check_config.h" 4216 4217 #endif /* MBEDTLS_CONFIG_H */ 4218