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