types.h (82314B)
1 /* types.h 2 * 3 * Copyright (C) 2006-2025 wolfSSL Inc. 4 * 5 * This file is part of wolfSSL. 6 * 7 * wolfSSL is free software; you can redistribute it and/or modify 8 * it under the terms of the GNU General Public License as published by 9 * the Free Software Foundation; either version 3 of the License, or 10 * (at your option) any later version. 11 * 12 * wolfSSL is distributed in the hope that it will be useful, 13 * but WITHOUT ANY WARRANTY; without even the implied warranty of 14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 * GNU General Public License for more details. 16 * 17 * You should have received a copy of the GNU General Public License 18 * along with this program; if not, write to the Free Software 19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335, USA 20 */ 21 22 /*! 23 \file wolfssl/wolfcrypt/types.h 24 */ 25 /* 26 DESCRIPTION 27 This library defines the primitive data types and abstraction macros to 28 decouple library dependencies with standard string, memory and so on. 29 30 */ 31 #ifndef WOLF_CRYPT_TYPES_H 32 #define WOLF_CRYPT_TYPES_H 33 34 #include <wolfssl/wolfcrypt/settings.h> 35 #include <wolfssl/wolfcrypt/wc_port.h> 36 #include <wolfssl/wolfcrypt/oid_sum.h> 37 38 #if defined(EXTERNAL_OPTS_OPENVPN) && defined(BUILDING_WOLFSSL) 39 #error EXTERNAL_OPTS_OPENVPN should not be defined in compiled wolfssl \ 40 library files. 41 #endif 42 43 #ifdef __APPLE__ 44 #include <AvailabilityMacros.h> 45 #endif 46 47 #ifdef __cplusplus 48 extern "C" { 49 #endif 50 51 52 /* 53 * This struct is used multiple time by other structs and 54 * needs to be defined somewhere that all structs can import 55 * (with minimal dependencies). 56 */ 57 #ifdef HAVE_EX_DATA 58 #ifdef HAVE_EX_DATA_CLEANUP_HOOKS 59 typedef void (*wolfSSL_ex_data_cleanup_routine_t)(void *data); 60 #endif 61 typedef struct WOLFSSL_CRYPTO_EX_DATA { 62 void* ex_data[MAX_EX_DATA]; 63 #ifdef HAVE_EX_DATA_CLEANUP_HOOKS 64 wolfSSL_ex_data_cleanup_routine_t 65 ex_data_cleanup_routines[MAX_EX_DATA]; 66 #endif 67 } WOLFSSL_CRYPTO_EX_DATA; 68 typedef void (WOLFSSL_CRYPTO_EX_new)(void* p, void* ptr, 69 WOLFSSL_CRYPTO_EX_DATA* a, int idx, long argValue, void* arg); 70 typedef int (WOLFSSL_CRYPTO_EX_dup)(WOLFSSL_CRYPTO_EX_DATA* out, 71 const WOLFSSL_CRYPTO_EX_DATA* in, void* inPtr, int idx, 72 long argV, void* arg); 73 typedef void (WOLFSSL_CRYPTO_EX_free)(void* p, void* ptr, 74 WOLFSSL_CRYPTO_EX_DATA* a, int idx, long argValue, void* arg); 75 #endif 76 77 #if defined(WORDS_BIGENDIAN) 78 #define BIG_ENDIAN_ORDER 79 #endif 80 81 #ifndef BIG_ENDIAN_ORDER 82 #define LITTLE_ENDIAN_ORDER 83 #endif 84 85 #ifndef WOLFSSL_TYPES 86 #define WOLFSSL_TYPES 87 #ifndef byte 88 /* If using C++ C17 or later and getting: 89 * "error: reference to 'byte' is ambiguous", this is caused by 90 * cstddef conflict with "std::byte" in 91 * "enum class byte : unsigned char {};". 92 * This can occur if the user application is using "std" as the 93 * default namespace before including wolfSSL headers. 94 * Workarounds: https://github.com/wolfSSL/wolfssl/issues/5400 95 */ 96 typedef unsigned char byte; 97 #endif 98 typedef signed char sword8; 99 typedef unsigned char word8; 100 #ifdef WC_16BIT_CPU 101 typedef int sword16; 102 typedef unsigned int word16; 103 typedef long sword32; 104 typedef unsigned long word32; 105 #else 106 typedef short sword16; 107 typedef unsigned short word16; 108 typedef int sword32; 109 typedef unsigned int word32; 110 #endif 111 typedef byte word24[3]; 112 #endif 113 114 typedef const char wcchar[]; 115 116 #ifndef WC_BITFIELD 117 #ifdef WOLF_C89 118 #define WC_BITFIELD unsigned 119 #else 120 #define WC_BITFIELD byte 121 #endif 122 #endif 123 124 #ifndef HAVE_ANONYMOUS_INLINE_AGGREGATES 125 /* if a version is available, pivot on the version, otherwise guess it's 126 * disallowed, subject to override. 127 */ 128 #if !defined(WOLF_C89) && (!defined(__STDC__) \ 129 || (!defined(__STDC_VERSION__) && !defined(__cplusplus)) \ 130 || (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201101L)) \ 131 || (defined(__cplusplus) && (__cplusplus >= 201103L))) 132 #define HAVE_ANONYMOUS_INLINE_AGGREGATES 1 133 #endif 134 #elif ~(~HAVE_ANONYMOUS_INLINE_AGGREGATES + 1) == 1 135 /* forced on with empty value -- remap to 1 */ 136 #undef HAVE_ANONYMOUS_INLINE_AGGREGATES 137 #define HAVE_ANONYMOUS_INLINE_AGGREGATES 1 138 #elif HAVE_ANONYMOUS_INLINE_AGGREGATES 139 /* forced on with explicit nonzero value -- leave as-is. */ 140 #else 141 /* forced off with explicit zero value -- remap to undef. */ 142 #undef HAVE_ANONYMOUS_INLINE_AGGREGATES 143 #endif 144 145 #ifndef HAVE_EMPTY_AGGREGATES 146 /* The C standards don't define empty aggregates, but gcc and clang do. 147 * We need to accommodate them for one of the same reasons C++ does -- 148 * conditionally empty aggregates, e.g. in hash.h. 149 * 150 * Nonetheless, in C++, empty aggregates wind up with size 1. If we use 151 * the [0] construct and the header is compiled by clang++, it warns 152 * "struct has size 0 in C, size 1 in C++ [-Wextern-c-compat]", despite 153 * the extern "C" wrapper. We sidestep this warning by recognizing 154 * here that C++ doesn't support truly empty aggregates. LLVM, for its 155 * part, deprecates compilation of C code as C++ using clang++. 156 */ 157 #if !defined(WOLF_C89) && defined(__GNUC__) && \ 158 !defined(__STRICT_ANSI__) && \ 159 !defined(__cplusplus) && \ 160 defined(HAVE_ANONYMOUS_INLINE_AGGREGATES) 161 #define HAVE_EMPTY_AGGREGATES 1 162 #endif 163 #elif ~(~HAVE_EMPTY_AGGREGATES + 1) == 1 164 /* forced on with empty value -- remap to 1 */ 165 #undef HAVE_EMPTY_AGGREGATES 166 #define HAVE_EMPTY_AGGREGATES 1 167 #elif HAVE_EMPTY_AGGREGATES 168 /* forced on with explicit nonzero value -- leave as-is. */ 169 #else 170 /* forced off with explicit zero value -- remap to undef. */ 171 #undef HAVE_EMPTY_AGGREGATES 172 #endif 173 174 #define _WOLF_AGG_DUMMY_MEMBER_HELPER2(a, b, c) a ## b ## c 175 #define _WOLF_AGG_DUMMY_MEMBER_HELPER(a, b, c) \ 176 _WOLF_AGG_DUMMY_MEMBER_HELPER2(a, b, c) 177 #ifdef HAVE_EMPTY_AGGREGATES 178 /* swallow the semicolon with a zero-sized array (language extension 179 * specific to gcc/clang). 180 */ 181 #define WOLF_AGG_DUMMY_MEMBER \ 182 struct { \ 183 PRAGMA_GCC_DIAG_PUSH \ 184 PRAGMA_GCC("GCC diagnostic ignored \"-Wpedantic\"") \ 185 PRAGMA_CLANG_DIAG_PUSH \ 186 PRAGMA_CLANG("clang diagnostic ignored \"-Wzero-length-array\"") \ 187 byte _WOLF_AGG_DUMMY_MEMBER_HELPER(_wolf_L, __LINE__, \ 188 _agg_dummy_member)[0]; \ 189 PRAGMA_CLANG_DIAG_POP \ 190 PRAGMA_GCC_DIAG_POP \ 191 } 192 #else 193 /* Use a single byte with a constructed name as a dummy member -- these 194 * are the standard semantics of an empty structure in C++. 195 */ 196 #define WOLF_AGG_DUMMY_MEMBER char _WOLF_AGG_DUMMY_MEMBER_HELPER( \ 197 _wolf_L, __LINE__, _agg_dummy_member) 198 #endif 199 200 /* helpers for stringifying the expanded value of a macro argument rather 201 * than its literal text: 202 */ 203 #define _WC_STRINGIFY_L2(str) #str 204 #define WC_STRINGIFY(str) _WC_STRINGIFY_L2(str) 205 206 /* With a true C89-dialect compiler (simulate with gcc -std=c89 -Wall 207 * -Wextra -pedantic), a trailing comma on the last value in an enum 208 * definition is a syntax error. We use this macro to accommodate that 209 * without disrupting clean flow/syntax when some enum values are 210 * preprocessor-gated. 211 */ 212 #if defined(WOLF_C89) || defined(WOLF_NO_TRAILING_ENUM_COMMAS) 213 #define _WOLF_ENUM_DUMMY_LAST_ELEMENT_HELPER2(a, b, c, d, e) \ 214 a ## b ## c ## d ## e 215 #define _WOLF_ENUM_DUMMY_LAST_ELEMENT_HELPER(a, b, c, d, e) \ 216 _WOLF_ENUM_DUMMY_LAST_ELEMENT_HELPER2(a, b, c, d, e) 217 #define WOLF_ENUM_DUMMY_LAST_ELEMENT(prefix) \ 218 _WOLF_ENUM_DUMMY_LAST_ELEMENT_HELPER(_wolf_, prefix, _L, __LINE__, \ 219 _enum_dummy_last_element) 220 #else 221 #define WOLF_ENUM_DUMMY_LAST_ELEMENT(prefix) /* null expansion */ 222 #endif 223 224 /* try to set SIZEOF_LONG or SIZEOF_LONG_LONG if user didn't */ 225 #if defined(_WIN32) || defined(HAVE_LIMITS_H) 226 #include <limits.h> 227 /* make sure both SIZEOF_LONG_LONG and SIZEOF_LONG are set, 228 * otherwise causes issues with CTC_SETTINGS */ 229 #if !defined(SIZEOF_LONG_LONG) || !defined(SIZEOF_LONG) 230 #if !defined(SIZEOF_LONG) && defined(ULONG_MAX) && \ 231 (ULONG_MAX == 0xffffffffUL) 232 #define SIZEOF_LONG 4 233 #endif 234 #if !defined(SIZEOF_LONG_LONG) && defined(ULLONG_MAX) && \ 235 (ULLONG_MAX == 0xffffffffffffffffULL) 236 #define SIZEOF_LONG_LONG 8 237 #endif 238 #endif 239 #elif !defined(__BCPLUSPLUS__) && !defined(__EMSCRIPTEN__) 240 #if !defined(SIZEOF_LONG_LONG) && !defined(SIZEOF_LONG) 241 #if (defined(__alpha__) || defined(__ia64__) || \ 242 defined(_ARCH_PPC64) || defined(__ppc64__) || \ 243 defined(__x86_64__) || defined(__s390x__ ) || \ 244 ((defined(sun) || defined(__sun)) && \ 245 (defined(LP64) || defined(_LP64))) || \ 246 (defined(__riscv_xlen) && (__riscv_xlen == 64)) || \ 247 defined(__aarch64__) || defined(__mips64) || \ 248 (defined(__DCC__) && (defined(__LP64) || defined(__LP64__)))) 249 /* long should be 64bit */ 250 #define SIZEOF_LONG 8 251 #elif defined(__i386__) || defined(__CORTEX_M3__) || defined(__ppc__) 252 /* long long should be 64bit */ 253 #define SIZEOF_LONG_LONG 8 254 #endif 255 #endif 256 #endif 257 258 #if (defined(_MSC_VER) && (_MSC_VER == 1200)) || /* MSVC6 */ \ 259 (defined(_MSC_VER) && !defined(WOLFSSL_NOT_WINDOWS_API)) || \ 260 defined(__BCPLUSPLUS__) || \ 261 (defined(__WATCOMC__) && defined(__WATCOM_INT64__)) 262 /* windows types */ 263 #define WORD64_AVAILABLE 264 #define W64LIT(x) x##ui64 265 #define SW64LIT(x) x##i64 266 typedef __int64 sword64; 267 typedef unsigned __int64 word64; 268 #elif defined(__EMSCRIPTEN__) 269 #define WORD64_AVAILABLE 270 #define W64LIT(x) x##ull 271 #define SW64LIT(x) x##ll 272 typedef long long sword64; 273 typedef unsigned long long word64; 274 #elif defined(SIZEOF_LONG) && SIZEOF_LONG == 8 275 #define WORD64_AVAILABLE 276 #ifdef WOLF_C89 277 #define W64LIT(x) x##UL 278 #define SW64LIT(x) x##L 279 #else 280 #define W64LIT(x) x##ULL 281 #define SW64LIT(x) x##LL 282 #endif 283 typedef long sword64; 284 typedef unsigned long word64; 285 #elif defined(SIZEOF_LONG_LONG) && SIZEOF_LONG_LONG == 8 286 #define WORD64_AVAILABLE 287 #ifdef WOLF_C89 288 #define W64LIT(x) x##UL 289 #define SW64LIT(x) x##L 290 #else 291 #define W64LIT(x) x##ULL 292 #define SW64LIT(x) x##LL 293 #endif 294 typedef long long sword64; 295 typedef unsigned long long word64; 296 #elif defined(__SIZEOF_LONG_LONG__) && __SIZEOF_LONG_LONG__ == 8 297 #define WORD64_AVAILABLE 298 #ifdef WOLF_C89 299 #define W64LIT(x) x##UL 300 #define SW64LIT(x) x##L 301 #else 302 #define W64LIT(x) x##ULL 303 #define SW64LIT(x) x##LL 304 #endif 305 typedef long long sword64; 306 typedef unsigned long long word64; 307 #endif 308 309 #if defined(WORD64_AVAILABLE) && !defined(WC_16BIT_CPU) 310 /* These platforms have 64-bit CPU registers. */ 311 #if (defined(__alpha__) || defined(__ia64__) || defined(_ARCH_PPC64) || \ 312 (defined(__mips64) && \ 313 ((defined(_ABI64) && (_MIPS_SIM == _ABI64)) || \ 314 (defined(_ABIO64) && (_MIPS_SIM == _ABIO64)))) || \ 315 defined(__x86_64__) || defined(_M_X64)) || \ 316 defined(__aarch64__) || defined(__sparc64__) || defined(__s390x__ ) || \ 317 (defined(__riscv_xlen) && (__riscv_xlen == 64)) || defined(_M_ARM64) || \ 318 defined(__aarch64__) || defined(__ppc64__) || \ 319 (defined(__DCC__) && (defined(__LP64) || defined(__LP64__))) 320 #define WC_64BIT_CPU 321 #elif (defined(sun) || defined(__sun)) && \ 322 (defined(LP64) || defined(_LP64)) 323 /* LP64 with GNU GCC compiler is reserved for when long int is 64 bits 324 * and int uses 32 bits. When using Solaris Studio sparc and __sparc are 325 * available for 32 bit detection but __sparc64__ could be missed. This 326 * uses LP64 for checking 64 bit CPU arch. */ 327 #define WC_64BIT_CPU 328 #else 329 #define WC_32BIT_CPU 330 #endif 331 332 #if defined(NO_64BIT) 333 typedef word32 wolfssl_word; 334 #define WOLFSSL_WORD_SIZE_LOG2 2 335 #undef WORD64_AVAILABLE 336 #else 337 #ifdef WC_64BIT_CPU 338 typedef word64 wolfssl_word; 339 #define WOLFSSL_WORD_SIZE_LOG2 3 340 #else 341 typedef word32 wolfssl_word; 342 #define WOLFSSL_WORD_SIZE_LOG2 2 343 #ifdef WORD64_AVAILABLE 344 #define WOLFCRYPT_SLOW_WORD64 345 #endif 346 #endif 347 #endif 348 349 #elif defined(WC_16BIT_CPU) 350 #ifndef MICROCHIP_PIC24 351 #undef WORD64_AVAILABLE 352 #endif 353 typedef word16 wolfssl_word; 354 #define WOLFSSL_WORD_SIZE_LOG2 1 355 #define MP_16BIT /* for mp_int, mp_word needs to be twice as big as \ 356 * mp_digit, no 64 bit type so make mp_digit 16 bit */ 357 358 #else 359 #undef WORD64_AVAILABLE 360 typedef word32 wolfssl_word; 361 #define WOLFSSL_WORD_SIZE_LOG2 2 362 #define MP_16BIT /* for mp_int, mp_word needs to be twice as big as \ 363 * mp_digit, no 64 bit type so make mp_digit 16 bit */ 364 #endif 365 366 typedef struct w64wrapper { 367 #if defined(WORD64_AVAILABLE) && !defined(WOLFSSL_W64_WRAPPER_TEST) 368 word64 n; 369 #else 370 word32 n[2]; 371 #endif /* WORD64_AVAILABLE && WOLFSSL_W64_WRAPPER_TEST */ 372 } w64wrapper; 373 374 #ifdef WC_PTR_TYPE /* Allow user supplied type */ 375 typedef WC_PTR_TYPE wc_ptr_t; 376 #elif defined(HAVE_UINTPTR_T) 377 #include <stdint.h> 378 typedef uintptr_t wc_ptr_t; 379 #else /* fallback to architecture size_t for pointer size */ 380 #include <stddef.h> /* included for getting size_t type */ 381 typedef size_t wc_ptr_t; 382 #endif 383 384 enum { 385 WOLFSSL_WORD_SIZE = sizeof(wolfssl_word), 386 WOLFSSL_BIT_SIZE = 8, 387 WOLFSSL_WORD_BITS = WOLFSSL_WORD_SIZE * WOLFSSL_BIT_SIZE 388 }; 389 390 #define WOLFSSL_MAX_8BIT 0xffU 391 #define WOLFSSL_MAX_16BIT 0xffffU 392 #define WOLFSSL_MAX_32BIT 0xffffffffU 393 394 #ifndef WC_DO_NOTHING 395 #define WC_DO_NOTHING do {} while (0) 396 #ifdef _MSC_VER 397 /* disable buggy MSC warning around while(0), 398 *"warning C4127: conditional expression is constant" 399 */ 400 #pragma warning(disable: 4127) 401 #endif 402 #endif 403 404 #if defined(HAVE_FIPS) || defined(HAVE_SELFTEST) 405 #define INLINE WC_INLINE 406 #endif 407 408 /* set up rotate style */ 409 #if ((defined(_MSC_VER) && !defined(WOLFSSL_NOT_WINDOWS_API)) || \ 410 defined(__BCPLUSPLUS__)) && !defined(WOLFSSL_SGX) && \ 411 !defined(INTIME_RTOS) 412 #define INTEL_INTRINSICS 413 #define FAST_ROTATE 414 #elif defined(__MWERKS__) && TARGET_CPU_PPC 415 #define PPC_INTRINSICS 416 #define FAST_ROTATE 417 #elif defined(__CCRX__) 418 #define FAST_ROTATE 419 #elif defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__)) 420 /* GCC does peephole optimizations which should result in using rotate 421 instructions */ 422 #define FAST_ROTATE 423 #endif 424 425 /* set up thread local storage if available */ 426 #ifdef HAVE_THREAD_LS 427 #if defined(_MSC_VER) || defined(__WATCOMC__) 428 #define THREAD_LS_T __declspec(thread) 429 /* Thread local storage only in FreeRTOS v8.2.1 and higher */ 430 #elif defined(FREERTOS) || defined(FREERTOS_TCP) || \ 431 defined(WOLFSSL_ZEPHYR) 432 #define THREAD_LS_T 433 #else 434 #define THREAD_LS_T __thread 435 #endif 436 #else 437 #define THREAD_LS_T 438 #endif 439 440 #ifndef FALL_THROUGH 441 /* GCC 7 has new switch() fall-through detection */ 442 #if defined(__GNUC__) 443 #if defined(fallthrough) 444 #define FALL_THROUGH fallthrough 445 #elif ((__GNUC__ > 7) || ((__GNUC__ == 7) && (__GNUC_MINOR__ >= 1))) 446 #define FALL_THROUGH ; __attribute__ ((fallthrough)) 447 #elif defined(__clang__) && defined(__clang_major__) && \ 448 (__clang_major__ >= 12) 449 #define FALL_THROUGH ; __attribute__ ((fallthrough)) 450 #endif 451 #endif 452 #endif /* FALL_THROUGH */ 453 #if !defined(FALL_THROUGH) || defined(__XC32) 454 /* use stub for fall through by default or for Microchip compiler */ 455 #undef FALL_THROUGH 456 #define FALL_THROUGH 457 #endif 458 459 #define XSTR_SIZEOF(x) (sizeof(x) - 1) /* -1 to not count the null char */ 460 461 #define XELEM_CNT(x) (sizeof((x))/sizeof(*(x))) 462 463 #define WC_SAFE_SUM_WORD32(in1, in2, out) ((in2) <= 0xffffffffU - (in1) ? \ 464 ((out) = (in1) + (in2), 1) : ((out) = 0xffffffffU, 0)) 465 466 #if defined(HAVE_IO_POOL) 467 WOLFSSL_API void* XMALLOC(size_t n, void* heap, int type); 468 WOLFSSL_API void* XREALLOC(void *p, size_t n, void* heap, int type); 469 WOLFSSL_API void XFREE(void *p, void* heap, int type); 470 #elif (defined(WOLFSSL_ASYNC_CRYPT) && defined(HAVE_INTEL_QA)) || \ 471 defined(HAVE_INTEL_QA_SYNC) 472 #ifndef HAVE_INTEL_QA_SYNC 473 #include <wolfssl/wolfcrypt/port/intel/quickassist_mem.h> 474 #undef USE_WOLFSSL_MEMORY 475 #ifdef WOLFSSL_DEBUG_MEMORY 476 #define XMALLOC(s, h, t) \ 477 IntelQaMalloc((s), (h), (t), __func__, __LINE__) 478 #define XFREE(p, h, t) \ 479 IntelQaFree((p), (h), (t), __func__, __LINE__) 480 #define XREALLOC(p, n, h, t) \ 481 IntelQaRealloc((p), (n), (h), (t), __func__, __LINE__) 482 #else 483 #define XMALLOC(s, h, t) IntelQaMalloc((s), (h), (t)) 484 #define XFREE(p, h, t) IntelQaFree((p), (h), (t)) 485 #define XREALLOC(p, n, h, t) IntelQaRealloc((p), (n), (h), (t)) 486 #endif /* WOLFSSL_DEBUG_MEMORY */ 487 #else 488 #include <wolfssl/wolfcrypt/port/intel/quickassist_sync.h> 489 #undef USE_WOLFSSL_MEMORY 490 #ifdef WOLFSSL_DEBUG_MEMORY 491 #define XMALLOC(s, h, t) \ 492 wc_CryptoCb_IntelQaMalloc((s), (h), (t), __func__, __LINE__) 493 #define XFREE(p, h, t) \ 494 wc_CryptoCb_IntelQaFree((p), (h), (t), __func__, __LINE__) 495 #define XREALLOC(p, n, h, t) \ 496 wc_CryptoCb_IntelQaRealloc((p), (n), (h), (t), __func__, \ 497 __LINE__) 498 #else 499 #define XMALLOC(s, h, t) \ 500 wc_CryptoCb_IntelQaMalloc((s), (h), (t)) 501 #define XFREE(p, h, t) \ 502 wc_CryptoCb_IntelQaFree((p), (h), (t)) 503 #define XREALLOC(p, n, h, t) \ 504 wc_CryptoCb_IntelQaRealloc((p), (n), (h), (t)) 505 #endif /* WOLFSSL_DEBUG_MEMORY */ 506 #endif 507 #elif defined(XMALLOC_USER) 508 /* prototypes for user heap override functions */ 509 #include <stddef.h> /* for size_t */ 510 extern void *XMALLOC(size_t n, void* heap, int type); 511 extern void *XREALLOC(void *p, size_t n, void* heap, int type); 512 extern void XFREE(void *p, void* heap, int type); 513 #elif defined(WOLFSSL_MEMORY_LOG) 514 #define XMALLOC(n, h, t) xmalloc(n, h, t, __func__, __FILE__, __LINE__) 515 #define XREALLOC(p, n, h, t) \ 516 xrealloc(p, n, h, t, __func__, __FILE__, __LINE__) 517 #define XFREE(p, h, t) xfree(p, h, t, __func__, __FILE__, __LINE__) 518 519 /* prototypes for user heap override functions */ 520 #include <stddef.h> /* for size_t */ 521 #include <stdlib.h> 522 WOLFSSL_API void *xmalloc(size_t n, void* heap, int type, 523 const char* func, const char* file, unsigned int line); 524 WOLFSSL_API void *xrealloc(void *p, size_t n, void* heap, int type, 525 const char* func, const char* file, unsigned int line); 526 WOLFSSL_API void xfree(void *p, void* heap, int type, const char* func, 527 const char* file, unsigned int line); 528 #elif defined(XMALLOC_OVERRIDE) 529 /* override the XMALLOC, XFREE and XREALLOC macros */ 530 #elif defined(WOLFSSL_TELIT_M2MB) 531 /* Telit M2MB SDK requires use m2mb_os API's, not std malloc/free */ 532 /* Use of malloc/free will cause CPU reboot */ 533 #define XMALLOC(s, h, t) ((void)(h), (void)(t), \ 534 m2mb_os_malloc((s))) 535 #ifdef WOLFSSL_XFREE_NO_NULLNESS_CHECK 536 #define XFREE(p, h, t) m2mb_os_free(xp) 537 #else 538 #define XFREE(p, h, t) do { void* xp = (p); if (xp) \ 539 m2mb_os_free(xp); } while (0) 540 #endif 541 #define XREALLOC(p, n, h, t) m2mb_os_realloc((p), (n)) 542 543 #elif defined(NO_WOLFSSL_MEMORY) 544 #ifdef WOLFSSL_NO_MALLOC 545 /* this platform does not support heap use */ 546 #ifdef WOLFSSL_SMALL_STACK 547 #error WOLFSSL_SMALL_STACK requires a heap implementation. 548 #endif 549 #ifndef WC_NO_CONSTRUCTORS 550 #define WC_NO_CONSTRUCTORS 551 #endif 552 #ifdef WOLFSSL_MALLOC_CHECK 553 #ifndef NO_STDIO_FILESYSTEM 554 #include <stdio.h> 555 #endif 556 static inline void* malloc_check(size_t sz) { 557 fprintf(stderr, "wolfSSL_malloc failed"); 558 return NULL; 559 }; 560 #define XMALLOC(s, h, t) ((void)(h), (void)(t), malloc_check((s))) 561 #define XFREE(p, h, t) do { (void)(h); (void)(t); } while (0) 562 #define XREALLOC(p, n, h, t) ((void)(h), (void)(t), NULL) 563 #else 564 #define XMALLOC(s, h, t) ((void)(s), (void)(h), (void)(t), NULL) 565 #define XFREE(p, h, t) do { (void)(p); (void)(h); (void)(t); } while(0) 566 #define XREALLOC(p, n, h, t) ((void)(p), (void)(n), (void)(h), (void)(t), NULL) 567 #endif 568 #else 569 /* just use plain C stdlib stuff if desired */ 570 #include <stdlib.h> 571 #define XMALLOC(s, h, t) ((void)(h), (void)(t), malloc((size_t)(s))) /* native heap */ 572 #ifdef WOLFSSL_XFREE_NO_NULLNESS_CHECK 573 #define XFREE(p, h, t) do { (void)(h); (void)(t); free(p); } while (0) /* native heap */ 574 #else 575 #define XFREE(p, h, t) do { void* xp = (p); (void)(h); if (xp) free(xp); } while (0) /* native heap */ 576 #endif 577 #define XREALLOC(p, n, h, t) \ 578 ((void)(h), (void)(t), realloc((p), (size_t)(n))) /* native heap */ 579 #endif 580 581 #elif defined(WOLFSSL_LINUXKM) 582 583 /* definitions are in linuxkm/linuxkm_wc_port.h */ 584 585 #elif !defined(MICRIUM_MALLOC) && !defined(EBSNET) \ 586 && !defined(WOLFSSL_SAFERTOS) && !defined(FREESCALE_MQX) \ 587 && !defined(FREESCALE_KSDK_MQX) && !defined(FREESCALE_FREE_RTOS) \ 588 && !defined(WOLFSSL_LEANPSK) && !defined(WOLFSSL_uITRON4) 589 /* default C runtime, can install different routines at runtime via cbs */ 590 #ifndef WOLFSSL_MEMORY_H 591 #include <wolfssl/wolfcrypt/memory.h> 592 #endif 593 #ifdef WOLFSSL_STATIC_MEMORY 594 #ifdef WOLFSSL_DEBUG_MEMORY 595 #define XMALLOC(s, h, t) \ 596 wolfSSL_Malloc((s), (h), (t), __func__, __LINE__) 597 #ifdef WOLFSSL_XFREE_NO_NULLNESS_CHECK 598 #define XFREE(p, h, t) \ 599 wolfSSL_Free(xp, h, t, __func__, __LINE__) 600 #else 601 #define XFREE(p, h, t) do { void* xp = (p); if (xp) \ 602 wolfSSL_Free(xp, h, t, __func__, __LINE__); } while (0) 603 #endif 604 #define XREALLOC(p, n, h, t) \ 605 wolfSSL_Realloc((p), (n), (h), (t), __func__, __LINE__) 606 #else 607 #define XMALLOC(s, h, t) wolfSSL_Malloc((s), (h), (t)) 608 #ifdef WOLFSSL_XFREE_NO_NULLNESS_CHECK 609 #define XFREE(p, h, t) wolfSSL_Free(xp, h, t) 610 #else 611 #define XFREE(p, h, t) do { void* xp = (p); if (xp) \ 612 wolfSSL_Free(xp, h, t); } while (0) 613 #endif 614 #define XREALLOC(p, n, h, t) wolfSSL_Realloc((p), (n), (h), (t)) 615 #endif /* WOLFSSL_DEBUG_MEMORY */ 616 #elif defined(WOLFSSL_EMBOS) && !defined(XMALLOC_USER) \ 617 && !defined(NO_WOLFSSL_MEMORY) \ 618 && !defined(WOLFSSL_STATIC_MEMORY) 619 /* settings.h solve this case already. Avoid redefinition. */ 620 #elif (!defined(FREERTOS) && !defined(FREERTOS_TCP)) || \ 621 defined(WOLFSSL_TRACK_MEMORY) 622 #ifdef WOLFSSL_DEBUG_MEMORY 623 #define XMALLOC(s, h, t) ((void)(h), (void)(t), \ 624 wolfSSL_Malloc((s), __func__, __LINE__)) 625 #ifdef WOLFSSL_XFREE_NO_NULLNESS_CHECK 626 #define XFREE(p, h, t) do { (void)(h); (void)(t); \ 627 wolfSSL_Free(xp, __func__, __LINE__); } while (0) 628 #else 629 #define XFREE(p, h, t) do { void* xp = (p); (void)(h); \ 630 (void)(t); if (xp) wolfSSL_Free(xp, __func__, __LINE__); \ 631 } while (0) 632 #endif 633 #define XREALLOC(p, n, h, t) ((void)(h), (void)(t), \ 634 wolfSSL_Realloc((p), (n), __func__, __LINE__)) 635 #else 636 #define XMALLOC(s, h, t) ((void)(h), (void)(t), \ 637 wolfSSL_Malloc((s))) 638 #ifdef WOLFSSL_XFREE_NO_NULLNESS_CHECK 639 #define XFREE(p, h, t) do { (void)(h); (void)(t); \ 640 wolfSSL_Free(p); } while (0) 641 #else 642 #define XFREE(p, h, t) do { void* xp = (p); (void)(h); \ 643 (void)(t); if (xp) wolfSSL_Free(xp); } while (0) 644 #endif 645 #define XREALLOC(p, n, h, t) ((void)(h), (void)(t), \ 646 wolfSSL_Realloc((p), (n))) 647 #endif /* WOLFSSL_DEBUG_MEMORY */ 648 #endif /* WOLFSSL_STATIC_MEMORY */ 649 #endif 650 651 #if defined(WOLFSSL_SMALL_STACK) && defined(WC_NO_CONSTRUCTORS) 652 #error WOLFSSL_SMALL_STACK requires constructors. 653 #endif 654 655 #include <wolfssl/wolfcrypt/memory.h> 656 657 /* declare/free variable handling for async and smallstack */ 658 #ifndef WC_ALLOC_DO_ON_FAILURE 659 #define WC_ALLOC_DO_ON_FAILURE() WC_DO_NOTHING 660 #endif 661 662 #define WC_DECLARE_HEAP_ARRAY(VAR_NAME, VAR_TYPE, VAR_ITEMS, VAR_SIZE, HEAP) \ 663 VAR_TYPE* VAR_NAME[VAR_ITEMS] = { NULL, }; \ 664 int idx##VAR_NAME = 0, inner_idx_##VAR_NAME 665 #define WC_HEAP_ARRAY_ARG(VAR_NAME, VAR_TYPE, VAR_ITEMS, VAR_SIZE) \ 666 VAR_TYPE* VAR_NAME[VAR_ITEMS] 667 #define WC_ALLOC_HEAP_ARRAY(VAR_NAME, VAR_TYPE, VAR_ITEMS, VAR_SIZE, HEAP) \ 668 for (idx##VAR_NAME=0; idx##VAR_NAME<(VAR_ITEMS); idx##VAR_NAME++) { \ 669 (VAR_NAME)[idx##VAR_NAME] = (VAR_TYPE*)XMALLOC(VAR_SIZE, (HEAP), \ 670 DYNAMIC_TYPE_TMP_BUFFER); \ 671 if ((VAR_NAME)[idx##VAR_NAME] == NULL) { \ 672 for (inner_idx_##VAR_NAME = 0; \ 673 inner_idx_##VAR_NAME < idx##VAR_NAME; \ 674 inner_idx_##VAR_NAME++) { \ 675 XFREE((VAR_NAME)[inner_idx_##VAR_NAME], (HEAP), \ 676 DYNAMIC_TYPE_TMP_BUFFER); \ 677 (VAR_NAME)[inner_idx_##VAR_NAME] = NULL; \ 678 } \ 679 for (inner_idx_##VAR_NAME = idx##VAR_NAME + 1; \ 680 inner_idx_##VAR_NAME < (VAR_ITEMS); \ 681 inner_idx_##VAR_NAME++) { \ 682 (VAR_NAME)[inner_idx_##VAR_NAME] = NULL; \ 683 } \ 684 idx##VAR_NAME = 0; \ 685 WC_ALLOC_DO_ON_FAILURE(); \ 686 break; \ 687 } \ 688 } 689 #define WC_CALLOC_HEAP_ARRAY(VAR_NAME, VAR_TYPE, VAR_ITEMS, VAR_SIZE, HEAP) \ 690 do { \ 691 WC_ALLOC_HEAP_ARRAY(VAR_NAME, VAR_TYPE, VAR_ITEMS, VAR_SIZE, HEAP); \ 692 if (idx##VAR_NAME != 0) { \ 693 for (idx##VAR_NAME=0; \ 694 idx##VAR_NAME<(VAR_ITEMS); \ 695 idx##VAR_NAME++) { \ 696 XMEMSET((VAR_NAME)[idx##VAR_NAME], 0, VAR_SIZE); \ 697 } \ 698 } \ 699 } while (0) 700 #define WC_HEAP_ARRAY_OK(VAR_NAME) (idx##VAR_NAME != 0) 701 #define WC_FREE_HEAP_ARRAY(VAR_NAME, VAR_ITEMS, HEAP) \ 702 if (WC_HEAP_ARRAY_OK(VAR_NAME)) { \ 703 for (idx##VAR_NAME=0; idx##VAR_NAME<(VAR_ITEMS); idx##VAR_NAME++) { \ 704 XFREE((VAR_NAME)[idx##VAR_NAME], (HEAP), DYNAMIC_TYPE_TMP_BUFFER); \ 705 } \ 706 idx##VAR_NAME = 0; \ 707 } 708 709 #if defined(WOLFSSL_ASYNC_CRYPT) || defined(WOLFSSL_SMALL_STACK) 710 #define WC_DECLARE_VAR_IS_HEAP_ALLOC 711 #define WC_DECLARE_VAR(VAR_NAME, VAR_TYPE, VAR_SIZE, HEAP) \ 712 VAR_TYPE* VAR_NAME = NULL 713 #define WC_ALLOC_VAR(VAR_NAME, VAR_TYPE, VAR_SIZE, HEAP) \ 714 do { \ 715 (VAR_NAME) = (VAR_TYPE*)XMALLOC(sizeof(VAR_TYPE) * (VAR_SIZE), \ 716 (HEAP), DYNAMIC_TYPE_WOLF_BIGINT); \ 717 if ((VAR_NAME) == NULL) { \ 718 WC_ALLOC_DO_ON_FAILURE(); \ 719 } \ 720 } while (0) 721 #define WC_CALLOC_VAR(VAR_NAME, VAR_TYPE, VAR_SIZE, HEAP) \ 722 do { \ 723 WC_ALLOC_VAR(VAR_NAME, VAR_TYPE, VAR_SIZE, HEAP); \ 724 XMEMSET(VAR_NAME, 0, sizeof(VAR_TYPE) * (VAR_SIZE)); \ 725 } while (0) 726 #define WC_FREE_VAR(VAR_NAME, HEAP) \ 727 XFREE(VAR_NAME, (HEAP), DYNAMIC_TYPE_WOLF_BIGINT) 728 #define WC_DECLARE_ARRAY(VAR_NAME, VAR_TYPE, VAR_ITEMS, VAR_SIZE, HEAP) \ 729 WC_DECLARE_HEAP_ARRAY(VAR_NAME, VAR_TYPE, VAR_ITEMS, VAR_SIZE, HEAP) 730 #define WC_ARRAY_ARG(VAR_NAME, VAR_TYPE, VAR_ITEMS, VAR_SIZE) \ 731 WC_HEAP_ARRAY_ARG(VAR_NAME, VAR_TYPE, VAR_ITEMS, VAR_SIZE) 732 #define WC_ALLOC_ARRAY(VAR_NAME, VAR_TYPE, VAR_ITEMS, VAR_SIZE, HEAP) \ 733 WC_ALLOC_HEAP_ARRAY(VAR_NAME, VAR_TYPE, VAR_ITEMS, VAR_SIZE, HEAP) 734 #define WC_CALLOC_ARRAY(VAR_NAME, VAR_TYPE, VAR_ITEMS, VAR_SIZE, HEAP) \ 735 WC_CALLOC_HEAP_ARRAY(VAR_NAME, VAR_TYPE, VAR_ITEMS, VAR_SIZE, HEAP) 736 #define WC_ARRAY_OK(VAR_NAME) WC_HEAP_ARRAY_OK(VAR_NAME) 737 #define WC_FREE_ARRAY(VAR_NAME, VAR_ITEMS, HEAP) \ 738 WC_FREE_HEAP_ARRAY(VAR_NAME, VAR_ITEMS, HEAP) 739 #else 740 #undef WC_DECLARE_VAR_IS_HEAP_ALLOC 741 #define WC_DECLARE_VAR(VAR_NAME, VAR_TYPE, VAR_SIZE, HEAP) \ 742 VAR_TYPE VAR_NAME[VAR_SIZE] 743 #define WC_ALLOC_VAR(VAR_NAME, VAR_TYPE, VAR_SIZE, HEAP) WC_DO_NOTHING 744 #define WC_CALLOC_VAR(VAR_NAME, VAR_TYPE, VAR_SIZE, HEAP) \ 745 XMEMSET(VAR_NAME, 0, sizeof(var)) 746 #define WC_FREE_VAR(VAR_NAME, HEAP) WC_DO_NOTHING \ 747 /* nothing to free, its stack */ 748 #define WC_DECLARE_ARRAY(VAR_NAME, VAR_TYPE, VAR_ITEMS, VAR_SIZE, HEAP) \ 749 VAR_TYPE VAR_NAME[VAR_ITEMS][(VAR_SIZE) / sizeof(VAR_TYPE)] /* // NOLINT(bugprone-sizeof-expression) */ 750 #define WC_ARRAY_ARG(VAR_NAME, VAR_TYPE, VAR_ITEMS, VAR_SIZE) \ 751 VAR_TYPE VAR_NAME[VAR_ITEMS][(VAR_SIZE) / sizeof(VAR_TYPE)] /* // NOLINT(bugprone-sizeof-expression) */ 752 #define WC_ALLOC_ARRAY(VAR_NAME, VAR_TYPE, VAR_ITEMS, VAR_SIZE, HEAP) \ 753 WC_DO_NOTHING 754 #define WC_CALLOC_ARRAY(VAR_NAME, VAR_TYPE, VAR_ITEMS, VAR_SIZE, HEAP) \ 755 XMEMSET(VAR_NAME, 0, sizeof(VAR_NAME)) 756 #define WC_ARRAY_OK(VAR_NAME) 1 757 #define WC_FREE_ARRAY(VAR_NAME, VAR_ITEMS, HEAP) WC_DO_NOTHING \ 758 /* nothing to free, its stack */ 759 #endif 760 761 #if defined(HAVE_FIPS) || defined(HAVE_SELFTEST) 762 /* These are here for the FIPS code that can't be changed. 763 * New definitions don't need to be added here. */ 764 #define DECLARE_VAR WC_DECLARE_VAR 765 #define DECLARE_ARRAY WC_DECLARE_ARRAY 766 #define FREE_VAR WC_FREE_VAR 767 #define FREE_ARRAY WC_FREE_ARRAY 768 #define DECLARE_ARRAY_DYNAMIC_DEC WC_DECLARE_HEAP_ARRAY 769 #define DECLARE_ARRAY_DYNAMIC_EXE WC_ALLOC_HEAP_ARRAY 770 #define FREE_ARRAY_DYNAMIC WC_FREE_HEAP_ARRAY 771 #endif /* HAVE_FIPS */ 772 773 #if !defined(USE_WOLF_STRTOK) && \ 774 ((defined(__MINGW32__) && !defined(__MINGW64_VERSION_MAJOR)) || \ 775 defined(WOLFSSL_TIRTOS) || defined(WOLF_C99)) 776 #define USE_WOLF_STRTOK 777 #endif 778 #if !defined(USE_WOLF_STRSEP) && (defined(WOLF_C89) || defined(WOLF_C99)) 779 #define USE_WOLF_STRSEP 780 #endif 781 #if !defined(XSTRLCPY) && !defined(USE_WOLF_STRLCPY) 782 #define USE_WOLF_STRLCPY 783 #endif 784 #if !defined(XSTRLCAT) && !defined(USE_WOLF_STRLCAT) 785 #define USE_WOLF_STRLCAT 786 #endif 787 788 #ifndef STRING_USER 789 #if defined(WOLFSSL_LINUXKM) 790 #include <linux/string.h> 791 #else 792 #include <string.h> 793 #endif 794 795 #define XMEMCPY(d,s,l) memcpy((d),(s),(l)) 796 #define XMEMSET(b,c,l) memset((b),(c),(l)) 797 #define XMEMCMP(s1,s2,n) memcmp((s1),(s2),(n)) 798 #define XMEMMOVE(d,s,l) memmove((d),(s),(l)) 799 800 #define XSTRLEN(s1) strlen((s1)) 801 #define XSTRNCPY(s1,s2,n) strncpy((s1),(s2),(n)) 802 /* strstr, strncmp, strcmp, and strncat only used by wolfSSL proper, 803 * not required for wolfCrypt only */ 804 #define XSTRSTR(s1,s2) strstr((s1),(s2)) 805 #define XSTRNSTR(s1,s2,n) mystrnstr((s1),(s2),(n)) 806 #define XSTRNCMP(s1,s2,n) strncmp((s1),(s2),(n)) 807 #define XSTRCMP(s1,s2) strcmp((s1),(s2)) 808 #define XSTRNCAT(s1,s2,n) strncat((s1),(s2),(n)) 809 810 #ifdef USE_WOLF_STRSEP 811 #define XSTRSEP(s1,d) wc_strsep((s1),(d)) 812 #else 813 #define XSTRSEP(s1,d) strsep((s1),(d)) 814 #endif 815 816 #ifndef XSTRCASECMP 817 #if (defined(MICROCHIP_MPLAB_HARMONY) || defined(MICROCHIP_PIC32)) && \ 818 (__XC32_VERSION >= 1000) && (__XC32_VERSION < 4000) 819 /* XC32 supports str[n]casecmp in version >= 1.0 through 4.0. */ 820 #define XSTRCASECMP(s1,s2) strcasecmp((s1),(s2)) 821 #elif defined(MICROCHIP_MPLAB_HARMONY) || defined(MICROCHIP_PIC32) || \ 822 defined(WOLFSSL_TIRTOS) || defined(WOLFSSL_ZEPHYR) || \ 823 defined(MICROCHIP_PIC24) 824 /* XC32 version < 1.0 does not support strcasecmp. */ 825 #define USE_WOLF_STRCASECMP 826 #elif defined(USE_WINDOWS_API) || defined(FREERTOS_TCP_WINSIM) 827 #define XSTRCASECMP(s1,s2) _stricmp((s1),(s2)) 828 #else 829 #if defined(HAVE_STRINGS_H) && defined(WOLF_C99) && \ 830 !defined(WOLFSSL_SGX) 831 #include <strings.h> 832 #endif 833 #if defined(WOLFSSL_DEOS) 834 #define XSTRCASECMP(s1,s2) stricmp((s1),(s2)) 835 #elif defined(WOLFSSL_CMSIS_RTOSv2) || defined(WOLFSSL_AZSPHERE) \ 836 || defined(WOLF_C89) 837 #define USE_WOLF_STRCASECMP 838 #elif defined(WOLF_C89) 839 #define XSTRCASECMP(s1,s2) strcmp((s1),(s2)) 840 #else 841 #define XSTRCASECMP(s1,s2) strcasecmp((s1),(s2)) 842 #endif 843 #endif 844 #ifdef USE_WOLF_STRCASECMP 845 #undef XSTRCASECMP 846 #define XSTRCASECMP(s1,s2) wc_strcasecmp((s1), (s2)) 847 #endif 848 #endif /* !XSTRCASECMP */ 849 850 #ifndef XSTRNCASECMP 851 #if (defined(MICROCHIP_MPLAB_HARMONY) || defined(MICROCHIP_PIC32)) && \ 852 (__XC32_VERSION >= 1000) 853 /* XC32 supports str[n]casecmp in version >= 1.0. */ 854 #define XSTRNCASECMP(s1,s2,n) strncasecmp((s1),(s2),(n)) 855 #elif defined(MICROCHIP_MPLAB_HARMONY) || defined(MICROCHIP_PIC32) || \ 856 defined(WOLFSSL_TIRTOS) || defined(WOLFSSL_ZEPHYR) || \ 857 defined(MICROCHIP_PIC24) 858 /* XC32 version < 1.0 does not support strncasecmp. */ 859 #define USE_WOLF_STRNCASECMP 860 #elif defined(USE_WINDOWS_API) || defined(FREERTOS_TCP_WINSIM) 861 #define XSTRNCASECMP(s1,s2,n) _strnicmp((s1),(s2),(n)) 862 #else 863 #if defined(HAVE_STRINGS_H) && defined(WOLF_C99) && \ 864 !defined(WOLFSSL_SGX) 865 #include <strings.h> 866 #endif 867 #if defined(WOLFSSL_DEOS) 868 #define XSTRNCASECMP(s1,s2,n) strnicmp((s1),(s2),(n)) 869 #elif defined(WOLFSSL_CMSIS_RTOSv2) || defined(WOLFSSL_AZSPHERE) \ 870 || defined(WOLF_C89) 871 #define USE_WOLF_STRNCASECMP 872 #elif defined(WOLF_C89) 873 #define XSTRNCASECMP(s1,s2,n) strncmp((s1),(s2),(n)) 874 #else 875 #define XSTRNCASECMP(s1,s2,n) strncasecmp((s1),(s2),(n)) 876 #endif 877 #endif 878 #ifdef USE_WOLF_STRNCASECMP 879 #undef XSTRNCASECMP 880 #define XSTRNCASECMP(s1,s2,n) wc_strncasecmp((s1),(s2),(n)) 881 #endif 882 #endif /* !XSTRNCASECMP */ 883 884 /* snprintf is used in asn.c for GetTimeString, PKCS7 test, and when 885 * debugging is turned on */ 886 #ifndef XSNPRINTF 887 #ifndef USE_WINDOWS_API 888 #if defined(WOLFSSL_ESPIDF) && \ 889 (!defined(NO_ASN_TIME) && defined(HAVE_PKCS7)) 890 #include <stdarg.h> 891 /* later gcc than 7.1 introduces -Wformat-truncation */ 892 /* In cases when truncation is expected the caller needs*/ 893 /* to check the return value from the function so that */ 894 /* compiler doesn't complain. */ 895 /* xtensa-esp32-elf v8.2.0 warns truncation at */ 896 /* GetAsnTimeString() */ 897 static WC_INLINE 898 int _xsnprintf_(char *s, size_t n, const char *format, ...) 899 { 900 va_list ap; 901 int ret; 902 903 if ((int)n <= 0) return -1; 904 905 va_start(ap, format); 906 907 ret = XVSNPRINTF(s, n, format, ap); 908 if (ret < 0) 909 ret = -1; 910 911 va_end(ap); 912 913 return ret; 914 } 915 #define XSNPRINTF _xsnprintf_ 916 #elif defined(FREESCALE_MQX) 917 /* see wc_port.h for fio.h and nio.h includes. MQX does not 918 have stdio.h available, so it needs its own section. */ 919 #define XSNPRINTF snprintf 920 #elif defined(WOLF_C89) 921 #ifndef NO_STDIO_FILESYSTEM 922 #include <stdio.h> 923 #endif 924 #define XSPRINTF sprintf 925 /* snprintf not available for C89, so remap using macro */ 926 #ifdef WOLF_NO_VARIADIC_MACROS 927 #error WOLF_NO_VARIADIC_MACROS requires user-supplied \ 928 binding for XSNPRINTF 929 #else 930 #define XSNPRINTF(f, len, ...) sprintf(f, __VA_ARGS__) 931 #endif 932 #else 933 #ifndef NO_STDIO_FILESYSTEM 934 #include <stdio.h> 935 #endif 936 #define XSNPRINTF snprintf 937 #endif 938 #else 939 #if defined(_MSC_VER) || defined(__CYGWIN__) || defined(__MINGW32__) 940 #if defined(_MSC_VER) && (_MSC_VER >= 1900) 941 /* Beginning with the UCRT in Visual Studio 2015 and 942 * Windows 10, snprintf is no longer identical to 943 * _snprintf. The snprintf function behavior is now 944 * C99 standard compliant. */ 945 #include <stdio.h> 946 #define XSNPRINTF snprintf 947 #else 948 /* 4996 warning to use MS extensions e.g., _sprintf_s 949 * instead of _snprintf */ 950 #if !defined(__MINGW32__) 951 #pragma warning(disable: 4996) 952 #endif 953 #include <stdarg.h> 954 static WC_INLINE 955 int xsnprintf(char *buffer, size_t bufsize, 956 const char *format, ...) { 957 va_list ap; 958 int ret; 959 960 if ((int)bufsize <= 0) return -1; 961 va_start(ap, format); 962 ret = XVSNPRINTF(buffer, bufsize, format, ap); 963 if (ret >= (int)bufsize) 964 ret = -1; 965 va_end(ap); 966 return ret; 967 } 968 #define XSNPRINTF xsnprintf 969 #endif /* (_MSC_VER >= 1900) */ 970 #else 971 #define XSNPRINTF snprintf 972 #endif /* _MSC_VER */ 973 #endif /* USE_WINDOWS_API */ 974 #endif /* !XSNPRINTF */ 975 976 #if defined(WOLFSSL_CERT_EXT) || defined(OPENSSL_EXTRA) || \ 977 defined(HAVE_ALPN) || defined(WOLFSSL_SNIFFER) || \ 978 defined(WOLFSSL_ASN_PARSE_KEYUSAGE) 979 /* use only Thread Safe version of strtok */ 980 #if defined(USE_WOLF_STRTOK) 981 #define XSTRTOK(s1,d,ptr) wc_strtok((s1),(d),(ptr)) 982 #elif defined(__WATCOMC__) 983 #if __WATCOMC__ < 1300 984 #define USE_WOLF_STRTOK 985 #define XSTRTOK(s1,d,ptr) wc_strtok((s1),(d),(ptr)) 986 #else 987 #define XSTRTOK(s1,d,ptr) strtok_r((s1),(d),(ptr)) 988 #endif 989 #elif defined(USE_WINDOWS_API) || defined(INTIME_RTOS) 990 #define XSTRTOK(s1,d,ptr) strtok_s((s1),(d),(ptr)) 991 #else 992 #define XSTRTOK(s1,d,ptr) strtok_r((s1),(d),(ptr)) 993 #endif 994 #endif 995 996 #if defined(WOLFSSL_CERT_EXT) || defined(HAVE_OCSP) || \ 997 defined(HAVE_CRL_IO) || defined(HAVE_HTTP_CLIENT) || \ 998 !defined(NO_CRYPT_BENCHMARK) || defined(OPENSSL_EXTRA) 999 1000 #ifndef XATOI /* if custom XATOI is not already defined */ 1001 #include <stdlib.h> 1002 #define XATOI(s) atoi((s)) 1003 #endif 1004 #endif 1005 #endif /* STRING_USER */ 1006 1007 #ifdef USE_WOLF_STRTOK 1008 WOLFSSL_API char* wc_strtok(char *str, const char *delim, char **nextp); 1009 #endif 1010 #ifdef USE_WOLF_STRSEP 1011 WOLFSSL_API char* wc_strsep(char **stringp, const char *delim); 1012 #endif 1013 1014 #ifdef USE_WOLF_STRLCPY 1015 WOLFSSL_API size_t wc_strlcpy(char *dst, const char *src, size_t dstSize); 1016 #define XSTRLCPY(s1,s2,n) wc_strlcpy((s1),(s2),(n)) 1017 #endif 1018 #ifdef USE_WOLF_STRLCAT 1019 WOLFSSL_API size_t wc_strlcat(char *dst, const char *src, size_t dstSize); 1020 #define XSTRLCAT(s1,s2,n) wc_strlcat((s1),(s2),(n)) 1021 #endif 1022 #ifdef USE_WOLF_STRCASECMP 1023 WOLFSSL_API int wc_strcasecmp(const char *s1, const char *s2); 1024 #endif 1025 #ifdef USE_WOLF_STRNCASECMP 1026 WOLFSSL_API int wc_strncasecmp(const char *s1, const char *s2, size_t n); 1027 #endif 1028 1029 #if !defined(XSTRDUP) && !defined(USE_WOLF_STRDUP) 1030 #define USE_WOLF_STRDUP 1031 #endif 1032 #ifdef USE_WOLF_STRDUP 1033 WOLFSSL_LOCAL char* wc_strdup_ex(const char *src, int memType); 1034 #define wc_strdup(src) wc_strdup_ex(src, DYNAMIC_TYPE_TMP_BUFFER) 1035 #define XSTRDUP(src) wc_strdup(src) 1036 #endif 1037 1038 #if !defined(NO_FILESYSTEM) && !defined(NO_STDIO_FILESYSTEM) 1039 #ifndef XGETENV 1040 #ifdef NO_GETENV 1041 #define XGETENV(x) (NULL) 1042 #else 1043 #include <stdlib.h> 1044 #define XGETENV getenv 1045 #endif 1046 #endif 1047 #endif /* !NO_FILESYSTEM && !NO_STDIO_FILESYSTEM */ 1048 1049 #ifndef CTYPE_USER 1050 #ifndef WOLFSSL_LINUXKM 1051 #include <ctype.h> 1052 #endif 1053 #if defined(HAVE_ECC) || defined(HAVE_OCSP) || \ 1054 defined(WOLFSSL_KEY_GEN) || !defined(NO_DSA) || \ 1055 defined(OPENSSL_EXTRA) 1056 #define XTOUPPER(c) toupper((c)) 1057 #endif 1058 #if defined(OPENSSL_ALL) || defined(OPENSSL_EXTRA) || defined(OPENSSL_EXTRA_X509_SMALL) 1059 #define XISALNUM(c) isalnum((c)) 1060 #if !defined(HAVE_ISASCII) || defined(NO_STDLIB_ISASCII) 1061 #define XISASCII(c) (((c) >= 0 && (c) <= 127) ? 1 : 0) 1062 #else 1063 #define XISASCII(c) isascii((c)) 1064 #endif 1065 #define XISSPACE(c) isspace((c)) 1066 #endif 1067 /* needed by wolfSSL_check_domain_name() */ 1068 #define XTOLOWER(c) tolower((c)) 1069 #endif 1070 1071 #ifndef WC_OFFSETOF 1072 #if defined(__clang__) || (defined(__GNUC__) && (__GNUC__ >= 4)) 1073 #define WC_OFFSETOF(type, field) __builtin_offsetof(type, field) 1074 #elif defined(__WATCOMC__) 1075 #include <stddef.h> 1076 #define WC_OFFSETOF offsetof 1077 #else 1078 #define WC_OFFSETOF(type, field) ((size_t)&(((type *)0)->field)) 1079 #endif 1080 #endif 1081 1082 1083 /* memory allocation types for user hints */ 1084 enum { 1085 DYNAMIC_TYPE_CA = 1, 1086 DYNAMIC_TYPE_CERT = 2, 1087 DYNAMIC_TYPE_KEY = 3, 1088 DYNAMIC_TYPE_FILE = 4, 1089 DYNAMIC_TYPE_SUBJECT_CN = 5, 1090 DYNAMIC_TYPE_PUBLIC_KEY = 6, 1091 DYNAMIC_TYPE_SIGNER = 7, 1092 DYNAMIC_TYPE_NONE = 8, 1093 DYNAMIC_TYPE_BIGINT = 9, 1094 DYNAMIC_TYPE_RSA = 10, 1095 DYNAMIC_TYPE_METHOD = 11, 1096 DYNAMIC_TYPE_OUT_BUFFER = 12, 1097 DYNAMIC_TYPE_IN_BUFFER = 13, 1098 DYNAMIC_TYPE_INFO = 14, 1099 DYNAMIC_TYPE_DH = 15, 1100 DYNAMIC_TYPE_DOMAIN = 16, 1101 DYNAMIC_TYPE_SSL = 17, 1102 DYNAMIC_TYPE_CTX = 18, 1103 DYNAMIC_TYPE_WRITEV = 19, 1104 DYNAMIC_TYPE_OPENSSL = 20, 1105 DYNAMIC_TYPE_DSA = 21, 1106 DYNAMIC_TYPE_CRL = 22, 1107 DYNAMIC_TYPE_REVOKED = 23, 1108 DYNAMIC_TYPE_CRL_ENTRY = 24, 1109 DYNAMIC_TYPE_CERT_MANAGER = 25, 1110 DYNAMIC_TYPE_CRL_MONITOR = 26, 1111 DYNAMIC_TYPE_OCSP_STATUS = 27, 1112 DYNAMIC_TYPE_OCSP_ENTRY = 28, 1113 DYNAMIC_TYPE_ALTNAME = 29, 1114 DYNAMIC_TYPE_SUITES = 30, 1115 DYNAMIC_TYPE_CIPHER = 31, 1116 DYNAMIC_TYPE_RNG = 32, 1117 DYNAMIC_TYPE_ARRAYS = 33, 1118 DYNAMIC_TYPE_DTLS_POOL = 34, 1119 DYNAMIC_TYPE_SOCKADDR = 35, 1120 DYNAMIC_TYPE_LIBZ = 36, 1121 DYNAMIC_TYPE_ECC = 37, 1122 DYNAMIC_TYPE_TMP_BUFFER = 38, 1123 DYNAMIC_TYPE_DTLS_MSG = 39, 1124 DYNAMIC_TYPE_X509 = 40, 1125 DYNAMIC_TYPE_TLSX = 41, 1126 DYNAMIC_TYPE_OCSP = 42, 1127 DYNAMIC_TYPE_SIGNATURE = 43, 1128 DYNAMIC_TYPE_HASHES = 44, 1129 DYNAMIC_TYPE_SRP = 45, 1130 DYNAMIC_TYPE_COOKIE_PWD = 46, 1131 DYNAMIC_TYPE_USER_CRYPTO = 47, 1132 DYNAMIC_TYPE_OCSP_REQUEST = 48, 1133 DYNAMIC_TYPE_X509_EXT = 49, 1134 DYNAMIC_TYPE_X509_STORE = 50, 1135 DYNAMIC_TYPE_X509_CTX = 51, 1136 DYNAMIC_TYPE_URL = 52, 1137 DYNAMIC_TYPE_DTLS_FRAG = 53, 1138 DYNAMIC_TYPE_DTLS_BUFFER = 54, 1139 DYNAMIC_TYPE_SESSION_TICK = 55, 1140 DYNAMIC_TYPE_PKCS = 56, 1141 DYNAMIC_TYPE_MUTEX = 57, 1142 DYNAMIC_TYPE_PKCS7 = 58, 1143 DYNAMIC_TYPE_AES_BUFFER = 59, 1144 DYNAMIC_TYPE_WOLF_BIGINT = 60, 1145 DYNAMIC_TYPE_ASN1 = 61, 1146 DYNAMIC_TYPE_LOG = 62, 1147 DYNAMIC_TYPE_WRITEDUP = 63, 1148 DYNAMIC_TYPE_PRIVATE_KEY = 64, 1149 DYNAMIC_TYPE_HMAC = 65, 1150 DYNAMIC_TYPE_ASYNC = 66, 1151 DYNAMIC_TYPE_ASYNC_NUMA = 67, 1152 DYNAMIC_TYPE_ASYNC_NUMA64 = 68, 1153 DYNAMIC_TYPE_CURVE25519 = 69, 1154 DYNAMIC_TYPE_ED25519 = 70, 1155 DYNAMIC_TYPE_SECRET = 71, 1156 DYNAMIC_TYPE_DIGEST = 72, 1157 DYNAMIC_TYPE_RSA_BUFFER = 73, 1158 DYNAMIC_TYPE_DCERT = 74, 1159 DYNAMIC_TYPE_STRING = 75, 1160 DYNAMIC_TYPE_PEM = 76, 1161 DYNAMIC_TYPE_DER = 77, 1162 DYNAMIC_TYPE_CERT_EXT = 78, 1163 DYNAMIC_TYPE_ALPN = 79, 1164 DYNAMIC_TYPE_ENCRYPTEDINFO= 80, 1165 DYNAMIC_TYPE_DIRCTX = 81, 1166 DYNAMIC_TYPE_HASHCTX = 82, 1167 DYNAMIC_TYPE_SEED = 83, 1168 DYNAMIC_TYPE_SYMMETRIC_KEY= 84, 1169 DYNAMIC_TYPE_ECC_BUFFER = 85, 1170 DYNAMIC_TYPE_SALT = 87, 1171 DYNAMIC_TYPE_HASH_TMP = 88, 1172 DYNAMIC_TYPE_BLOB = 89, 1173 DYNAMIC_TYPE_NAME_ENTRY = 90, 1174 DYNAMIC_TYPE_CURVE448 = 91, 1175 DYNAMIC_TYPE_ED448 = 92, 1176 DYNAMIC_TYPE_AES = 93, 1177 DYNAMIC_TYPE_CMAC = 94, 1178 DYNAMIC_TYPE_FALCON = 95, 1179 DYNAMIC_TYPE_SESSION = 96, 1180 DYNAMIC_TYPE_DILITHIUM = 97, 1181 DYNAMIC_TYPE_SPHINCS = 98, 1182 DYNAMIC_TYPE_SM4_BUFFER = 99, 1183 DYNAMIC_TYPE_DEBUG_TAG = 100, 1184 DYNAMIC_TYPE_LMS = 101, 1185 DYNAMIC_TYPE_BIO = 102, 1186 DYNAMIC_TYPE_X509_ACERT = 103, 1187 DYNAMIC_TYPE_OS_BUF = 104, 1188 DYNAMIC_TYPE_ASCON = 105, 1189 DYNAMIC_TYPE_SNIFFER_SERVER = 1000, 1190 DYNAMIC_TYPE_SNIFFER_SESSION = 1001, 1191 DYNAMIC_TYPE_SNIFFER_PB = 1002, 1192 DYNAMIC_TYPE_SNIFFER_PB_BUFFER = 1003, 1193 DYNAMIC_TYPE_SNIFFER_TICKET_ID = 1004, 1194 DYNAMIC_TYPE_SNIFFER_NAMED_KEY = 1005, 1195 DYNAMIC_TYPE_SNIFFER_KEY = 1006, 1196 DYNAMIC_TYPE_SNIFFER_KEYLOG_NODE = 1007, 1197 DYNAMIC_TYPE_SNIFFER_CHAIN_BUFFER = 1008, 1198 DYNAMIC_TYPE_AES_EAX = 1009 1199 }; 1200 1201 /* max error buffer string size */ 1202 #ifndef WOLFSSL_MAX_ERROR_SZ 1203 #define WOLFSSL_MAX_ERROR_SZ 80 1204 #endif 1205 1206 /* stack protection */ 1207 enum { 1208 MIN_STACK_BUFFER = 8 1209 }; 1210 1211 1212 /* Algorithm Types */ 1213 enum wc_AlgoType { 1214 WC_ALGO_TYPE_NONE = 0, 1215 WC_ALGO_TYPE_HASH = 1, 1216 WC_ALGO_TYPE_CIPHER = 2, 1217 WC_ALGO_TYPE_PK = 3, 1218 WC_ALGO_TYPE_RNG = 4, 1219 WC_ALGO_TYPE_SEED = 5, 1220 WC_ALGO_TYPE_HMAC = 6, 1221 WC_ALGO_TYPE_CMAC = 7, 1222 WC_ALGO_TYPE_CERT = 8, 1223 1224 WC_ALGO_TYPE_MAX = WC_ALGO_TYPE_CERT 1225 }; 1226 1227 /* hash types */ 1228 enum wc_HashType { 1229 #if defined(HAVE_SELFTEST) || (defined(HAVE_FIPS) && \ 1230 ((! defined(HAVE_FIPS_VERSION)) || \ 1231 defined(HAVE_FIPS_VERSION) && (HAVE_FIPS_VERSION <= 2))) 1232 /* In selftest build, WC_* types are not mapped to WC_HASH_TYPE types. 1233 * Values here are based on old selftest hmac.h enum, with additions. 1234 * These values are fixed for backwards FIPS compatibility */ 1235 WC_HASH_TYPE_NONE = 15, 1236 WC_HASH_TYPE_MD2 = 16, 1237 WC_HASH_TYPE_MD4 = 17, 1238 WC_HASH_TYPE_MD5 = 0, 1239 WC_HASH_TYPE_SHA = 1, /* SHA-1 (not old SHA-0) */ 1240 WC_HASH_TYPE_SHA224 = 8, 1241 WC_HASH_TYPE_SHA256 = 2, 1242 WC_HASH_TYPE_SHA384 = 5, 1243 WC_HASH_TYPE_SHA512 = 4, 1244 WC_HASH_TYPE_MD5_SHA = 18, 1245 WC_HASH_TYPE_SHA3_224 = 10, 1246 WC_HASH_TYPE_SHA3_256 = 11, 1247 WC_HASH_TYPE_SHA3_384 = 12, 1248 WC_HASH_TYPE_SHA3_512 = 13, 1249 WC_HASH_TYPE_BLAKE2B = 14, 1250 WC_HASH_TYPE_BLAKE2S = 19, 1251 WC_HASH_TYPE_MAX = WC_HASH_TYPE_BLAKE2S, 1252 #ifndef WOLFSSL_NOSHA512_224 1253 #define WOLFSSL_NOSHA512_224 1254 #endif 1255 #ifndef WOLFSSL_NOSHA512_256 1256 #define WOLFSSL_NOSHA512_256 1257 #endif 1258 #else 1259 WC_HASH_TYPE_NONE = 0, 1260 WC_HASH_TYPE_MD2 = 1, 1261 WC_HASH_TYPE_MD4 = 2, 1262 WC_HASH_TYPE_MD5 = 3, 1263 WC_HASH_TYPE_SHA = 4, /* SHA-1 (not old SHA-0) */ 1264 WC_HASH_TYPE_SHA224 = 5, 1265 WC_HASH_TYPE_SHA256 = 6, 1266 WC_HASH_TYPE_SHA384 = 7, 1267 WC_HASH_TYPE_SHA512 = 8, 1268 WC_HASH_TYPE_MD5_SHA = 9, 1269 WC_HASH_TYPE_SHA3_224 = 10, 1270 WC_HASH_TYPE_SHA3_256 = 11, 1271 WC_HASH_TYPE_SHA3_384 = 12, 1272 WC_HASH_TYPE_SHA3_512 = 13, 1273 WC_HASH_TYPE_BLAKE2B = 14, 1274 WC_HASH_TYPE_BLAKE2S = 15, 1275 #define _WC_HASH_TYPE_MAX WC_HASH_TYPE_BLAKE2S 1276 #ifndef WOLFSSL_NOSHA512_224 1277 WC_HASH_TYPE_SHA512_224 = 16, 1278 #undef _WC_HASH_TYPE_MAX 1279 #define _WC_HASH_TYPE_MAX WC_HASH_TYPE_SHA512_224 1280 #endif 1281 #ifndef WOLFSSL_NOSHA512_256 1282 WC_HASH_TYPE_SHA512_256 = 17, 1283 #undef _WC_HASH_TYPE_MAX 1284 #define _WC_HASH_TYPE_MAX WC_HASH_TYPE_SHA512_256 1285 #endif 1286 #ifdef WOLFSSL_SHAKE128 1287 WC_HASH_TYPE_SHAKE128 = 18, 1288 #undef _WC_HASH_TYPE_MAX 1289 #define _WC_HASH_TYPE_MAX WC_HASH_TYPE_SHAKE128 1290 #endif 1291 #ifdef WOLFSSL_SHAKE256 1292 WC_HASH_TYPE_SHAKE256 = 19, 1293 #undef _WC_HASH_TYPE_MAX 1294 #define _WC_HASH_TYPE_MAX WC_HASH_TYPE_SHAKE256 1295 #endif 1296 #ifdef WOLFSSL_SM3 1297 WC_HASH_TYPE_SM3 = 20, 1298 #undef _WC_HASH_TYPE_MAX 1299 #define _WC_HASH_TYPE_MAX WC_HASH_TYPE_SM3 1300 #endif 1301 WC_HASH_TYPE_MAX = _WC_HASH_TYPE_MAX 1302 #undef _WC_HASH_TYPE_MAX 1303 1304 #endif /* HAVE_SELFTEST */ 1305 }; 1306 1307 enum wc_HashFlags { 1308 WC_HASH_FLAG_NONE = 0x00000000, 1309 WC_HASH_FLAG_WILLCOPY = 0x00000001, /* flag to indicate hash will be copied */ 1310 WC_HASH_FLAG_ISCOPY = 0x00000002, /* hash is copy */ 1311 #ifdef WOLFSSL_SHA3 1312 WC_HASH_SHA3_KECCAK256 =0x00010000, /* Older KECCAK256 */ 1313 #endif 1314 WOLF_ENUM_DUMMY_LAST_ELEMENT(WC_HASH) 1315 }; 1316 1317 /* cipher types */ 1318 enum wc_CipherType { 1319 WC_CIPHER_NONE = 0, 1320 WC_CIPHER_AES = 1, 1321 WC_CIPHER_AES_CBC = 2, 1322 WC_CIPHER_AES_GCM = 3, 1323 WC_CIPHER_AES_CTR = 4, 1324 WC_CIPHER_AES_XTS = 5, 1325 WC_CIPHER_AES_CFB = 6, 1326 WC_CIPHER_AES_CCM = 12, 1327 WC_CIPHER_AES_ECB = 13, 1328 WC_CIPHER_DES3 = 7, 1329 WC_CIPHER_DES = 8, 1330 WC_CIPHER_CHACHA = 9, 1331 1332 WC_CIPHER_MAX = WC_CIPHER_AES_CCM 1333 }; 1334 1335 /* PK=public key (asymmetric) based algorithms */ 1336 enum wc_PkType { 1337 WC_PK_TYPE_NONE = 0, 1338 WC_PK_TYPE_RSA = 1, 1339 WC_PK_TYPE_DH = 2, 1340 WC_PK_TYPE_ECDH = 3, 1341 WC_PK_TYPE_ECDSA_SIGN = 4, 1342 WC_PK_TYPE_ECDSA_VERIFY = 5, 1343 WC_PK_TYPE_ED25519_SIGN = 6, 1344 WC_PK_TYPE_CURVE25519 = 7, 1345 WC_PK_TYPE_RSA_KEYGEN = 8, 1346 WC_PK_TYPE_EC_KEYGEN = 9, 1347 WC_PK_TYPE_RSA_CHECK_PRIV_KEY = 10, 1348 WC_PK_TYPE_EC_CHECK_PRIV_KEY = 11, 1349 WC_PK_TYPE_ED448 = 12, 1350 WC_PK_TYPE_CURVE448 = 13, 1351 WC_PK_TYPE_ED25519_VERIFY = 14, 1352 WC_PK_TYPE_ED25519_KEYGEN = 15, 1353 WC_PK_TYPE_CURVE25519_KEYGEN = 16, 1354 WC_PK_TYPE_RSA_GET_SIZE = 17, 1355 #define _WC_PK_TYPE_MAX WC_PK_TYPE_RSA_GET_SIZE 1356 #if defined(WOLFSSL_HAVE_MLKEM) 1357 WC_PK_TYPE_PQC_KEM_KEYGEN = 18, 1358 WC_PK_TYPE_PQC_KEM_ENCAPS = 19, 1359 WC_PK_TYPE_PQC_KEM_DECAPS = 20, 1360 #undef _WC_PK_TYPE_MAX 1361 #define _WC_PK_TYPE_MAX WC_PK_TYPE_PQC_KEM_DECAPS 1362 #endif 1363 #if defined(HAVE_DILITHIUM) || defined(HAVE_FALCON) 1364 WC_PK_TYPE_PQC_SIG_KEYGEN = 21, 1365 WC_PK_TYPE_PQC_SIG_SIGN = 22, 1366 WC_PK_TYPE_PQC_SIG_VERIFY = 23, 1367 WC_PK_TYPE_PQC_SIG_CHECK_PRIV_KEY = 24, 1368 #undef _WC_PK_TYPE_MAX 1369 #define _WC_PK_TYPE_MAX WC_PK_TYPE_PQC_SIG_CHECK_PRIV_KEY 1370 #endif 1371 WC_PK_TYPE_RSA_PKCS = 25, 1372 WC_PK_TYPE_RSA_PSS = 26, 1373 WC_PK_TYPE_RSA_OAEP = 27, 1374 WC_PK_TYPE_MAX = _WC_PK_TYPE_MAX 1375 }; 1376 1377 #if defined(WOLFSSL_HAVE_MLKEM) 1378 /* Post quantum KEM algorithms */ 1379 enum wc_PqcKemType { 1380 WC_PQC_KEM_TYPE_NONE = 0, 1381 #define _WC_PQC_KEM_TYPE_MAX WC_PQC_KEM_TYPE_NONE 1382 #if defined(WOLFSSL_HAVE_MLKEM) 1383 WC_PQC_KEM_TYPE_KYBER = 1, 1384 #undef _WC_PQC_KEM_TYPE_MAX 1385 #define _WC_PQC_KEM_TYPE_MAX WC_PQC_KEM_TYPE_KYBER 1386 #endif 1387 WC_PQC_KEM_TYPE_MAX = _WC_PQC_KEM_TYPE_MAX 1388 }; 1389 #endif 1390 1391 #if defined(HAVE_DILITHIUM) || defined(HAVE_FALCON) 1392 /* Post quantum signature algorithms */ 1393 enum wc_PqcSignatureType { 1394 WC_PQC_SIG_TYPE_NONE = 0, 1395 #define _WC_PQC_SIG_TYPE_MAX WC_PQC_SIG_TYPE_NONE 1396 #if defined(HAVE_DILITHIUM) 1397 WC_PQC_SIG_TYPE_DILITHIUM = 1, 1398 #undef _WC_PQC_SIG_TYPE_MAX 1399 #define _WC_PQC_SIG_TYPE_MAX WC_PQC_SIG_TYPE_DILITHIUM 1400 #endif 1401 #if defined(HAVE_FALCON) 1402 WC_PQC_SIG_TYPE_FALCON = 2, 1403 #undef _WC_PQC_SIG_TYPE_MAX 1404 #define _WC_PQC_SIG_TYPE_MAX WC_PQC_SIG_TYPE_FALCON 1405 #endif 1406 WC_PQC_SIG_TYPE_MAX = _WC_PQC_SIG_TYPE_MAX 1407 }; 1408 #endif 1409 1410 1411 /* settings detection for compile vs runtime math incompatibilities */ 1412 enum { 1413 #if !defined(USE_FAST_MATH) && !defined(SIZEOF_LONG) && !defined(SIZEOF_LONG_LONG) 1414 CTC_SETTINGS = 0x0 1415 #elif !defined(USE_FAST_MATH) && defined(SIZEOF_LONG) && (SIZEOF_LONG == 8) 1416 CTC_SETTINGS = 0x1 1417 #elif !defined(USE_FAST_MATH) && defined(SIZEOF_LONG_LONG) && (SIZEOF_LONG_LONG == 8) 1418 CTC_SETTINGS = 0x2 1419 #elif !defined(USE_FAST_MATH) && defined(SIZEOF_LONG_LONG) && (SIZEOF_LONG_LONG == 4) 1420 CTC_SETTINGS = 0x4 1421 #elif defined(USE_FAST_MATH) && !defined(SIZEOF_LONG) && !defined(SIZEOF_LONG_LONG) 1422 CTC_SETTINGS = 0x8 1423 #elif defined(USE_FAST_MATH) && defined(SIZEOF_LONG) && (SIZEOF_LONG == 8) 1424 CTC_SETTINGS = 0x10 1425 #elif defined(USE_FAST_MATH) && defined(SIZEOF_LONG_LONG) && (SIZEOF_LONG_LONG == 8) 1426 CTC_SETTINGS = 0x20 1427 #elif defined(USE_FAST_MATH) && defined(SIZEOF_LONG_LONG) && (SIZEOF_LONG_LONG == 4) 1428 CTC_SETTINGS = 0x40 1429 #else 1430 #error "bad math long / long long settings" 1431 #endif 1432 }; 1433 1434 1435 WOLFSSL_API word32 CheckRunTimeSettings(void); 1436 1437 /* If user uses RSA, DH, DSA, or ECC math lib directly then fast math and long 1438 * types need to match at compile time and run time, CheckCtcSettings will 1439 * return 1 if a match otherwise 0 */ 1440 #define CheckCtcSettings() (CTC_SETTINGS == CheckRunTimeSettings()) 1441 1442 /* invalid device id */ 1443 #define INVALID_DEVID (-2) 1444 1445 #if defined(HAVE_FIPS) && FIPS_VERSION_LT(5,3) 1446 #ifdef XASM_LINK 1447 #error User-supplied XASM_LINK is not compatible with this FIPS version. 1448 #else 1449 /* use version in FIPS <=5.2 aes.c */ 1450 #endif 1451 #elif defined(XASM_LINK) 1452 /* keep user-supplied definition */ 1453 #elif defined(WOLFSSL_NO_ASM) 1454 #define XASM_LINK(f) /* null expansion */ 1455 #elif defined(_MSC_VER) 1456 #define XASM_LINK(f) /* null expansion */ 1457 #elif defined(__APPLE__) 1458 #define XASM_LINK(f) asm("_" f) 1459 #elif defined(__GNUC__) 1460 /* use alternate keyword for compatibility with -std=c99 */ 1461 #define XASM_LINK(f) __asm__(f) 1462 #else 1463 #define XASM_LINK(f) asm(f) 1464 #endif 1465 1466 /* AESNI requires alignment and ARMASM gains some performance from it. 1467 * Xilinx RSA operations require alignment. 1468 */ 1469 #if defined(WOLFSSL_AESNI) || defined(WOLFSSL_ARMASM) || \ 1470 defined(USE_INTEL_SPEEDUP) || defined(WOLFSSL_AFALG_XILINX) || \ 1471 defined(WOLFSSL_XILINX) 1472 #ifndef WOLFSSL_USE_ALIGN 1473 #define WOLFSSL_USE_ALIGN 1474 #endif 1475 #endif /* WOLFSSL_AESNI || WOLFSSL_ARMASM || USE_INTEL_SPEEDUP || \ 1476 * WOLFSSL_AFALG_XILINX */ 1477 1478 /* Helpers for memory alignment */ 1479 #ifndef XALIGNED 1480 #if defined(__GNUC__) || defined(__llvm__) || \ 1481 defined(__IAR_SYSTEMS_ICC__) 1482 #define XALIGNED(x) __attribute__ ( (aligned (x))) 1483 #elif defined(__KEIL__) 1484 #define XALIGNED(x) __align(x) 1485 #elif defined(_MSC_VER) 1486 /* disable align warning, we want alignment ! */ 1487 #pragma warning(disable: 4324) 1488 #define XALIGNED(x) __declspec (align (x)) 1489 #else 1490 #define XALIGNED(x) /* null expansion */ 1491 #endif 1492 #endif 1493 1494 /* Only use alignment in wolfSSL/wolfCrypt if WOLFSSL_USE_ALIGN is set */ 1495 #ifdef WOLFSSL_USE_ALIGN 1496 /* For IAR ARM the maximum variable alignment on stack is 8-bytes. 1497 * Variables declared outside stack (like static globals) can have 1498 * higher alignment. */ 1499 #if defined(__ICCARM__) 1500 #define WOLFSSL_ALIGN(x) XALIGNED(8) 1501 #else 1502 #define WOLFSSL_ALIGN(x) XALIGNED(x) 1503 #endif 1504 #else 1505 #define WOLFSSL_ALIGN(x) /* null expansion */ 1506 #endif 1507 1508 #ifndef ALIGN8 1509 #define ALIGN8 WOLFSSL_ALIGN(8) 1510 #endif 1511 #ifndef ALIGN16 1512 #define ALIGN16 WOLFSSL_ALIGN(16) 1513 #endif 1514 #ifndef ALIGN32 1515 #define ALIGN32 WOLFSSL_ALIGN(32) 1516 #endif 1517 #ifndef ALIGN64 1518 #define ALIGN64 WOLFSSL_ALIGN(64) 1519 #endif 1520 #ifndef ALIGN128 1521 #define ALIGN128 WOLFSSL_ALIGN(128) 1522 #endif 1523 #ifndef ALIGN256 1524 #define ALIGN256 WOLFSSL_ALIGN(256) 1525 #endif 1526 1527 #if !defined(PEDANTIC_EXTENSION) 1528 #if defined(__GNUC__) 1529 #define PEDANTIC_EXTENSION __extension__ 1530 #else 1531 #define PEDANTIC_EXTENSION 1532 #endif 1533 #endif /* !PEDANTIC_EXTENSION */ 1534 1535 1536 #ifndef TRUE 1537 #define TRUE 1 1538 #endif 1539 #ifndef FALSE 1540 #define FALSE 0 1541 #endif 1542 1543 #ifdef SINGLE_THREADED 1544 #if defined(WC_32BIT_CPU) || defined(HAVE_STACK_SIZE) 1545 typedef void* THREAD_RETURN; 1546 #else 1547 typedef unsigned int THREAD_RETURN; 1548 #endif 1549 typedef void* THREAD_TYPE; 1550 #define WOLFSSL_THREAD 1551 #elif defined(WOLFSSL_USER_THREADING) 1552 /* User can define user specific threading types 1553 * THREAD_RETURN 1554 * TREAD_TYPE 1555 * WOLFSSL_THREAD 1556 * e.g. 1557 * typedef unsigned int THREAD_RETURN; 1558 * typedef size_t THREAD_TYPE; 1559 * #define WOLFSSL_THREAD void 1560 * 1561 * User can also implement their own wolfSSL_NewThread(), 1562 * wolfSSL_JoinThread() and wolfSSL_Cond signaling if they want. 1563 * Otherwise, those functions are omitted. 1564 */ 1565 #elif defined(__WATCOMC__) 1566 #if __WATCOMC__ < 1300 1567 #define _WCCALLBACK 1568 #endif 1569 #if defined(__MACH__) 1570 #include <dispatch/dispatch.h> 1571 #include <pthread.h> 1572 typedef struct COND_TYPE { 1573 dispatch_semaphore_t cond; 1574 } COND_TYPE; 1575 typedef void* THREAD_RETURN; 1576 typedef pthread_t THREAD_TYPE; 1577 #define WOLFSSL_COND 1578 #define WOLFSSL_THREAD 1579 #ifndef HAVE_SELFTEST 1580 #define WOLFSSL_THREAD_NO_JOIN 1581 #endif 1582 #elif defined(__NT__) 1583 typedef unsigned THREAD_RETURN; 1584 typedef uintptr_t THREAD_TYPE; 1585 typedef struct COND_TYPE { 1586 wolfSSL_Mutex mutex; 1587 HANDLE cond; 1588 } COND_TYPE; 1589 #define WOLFSSL_COND 1590 #define INVALID_THREAD_VAL ((THREAD_TYPE)(INVALID_HANDLE_VALUE)) 1591 #define WOLFSSL_THREAD __stdcall 1592 #define WOLFSSL_THREAD_NO_JOIN _WCCALLBACK 1593 #elif defined(__OS2__) 1594 #define WOLFSSL_THREAD_VOID_RETURN 1595 typedef void THREAD_RETURN; 1596 typedef TID THREAD_TYPE; 1597 typedef struct COND_TYPE { 1598 wolfSSL_Mutex mutex; 1599 LHANDLE cond; 1600 } COND_TYPE; 1601 #define WOLFSSL_COND 1602 #define INVALID_THREAD_VAL ((THREAD_TYPE)(-1)) 1603 #define WOLFSSL_THREAD _WCCALLBACK 1604 #define WOLFSSL_THREAD_NO_JOIN _WCCALLBACK 1605 #elif defined(__LINUX__) 1606 #include <pthread.h> 1607 typedef struct COND_TYPE { 1608 pthread_mutex_t mutex; 1609 pthread_cond_t cond; 1610 } COND_TYPE; 1611 typedef void* THREAD_RETURN; 1612 typedef pthread_t THREAD_TYPE; 1613 #define WOLFSSL_COND 1614 #define WOLFSSL_THREAD 1615 #ifndef HAVE_SELFTEST 1616 #define WOLFSSL_THREAD_NO_JOIN 1617 #endif 1618 #endif 1619 #elif defined(WOLFSSL_MDK_ARM) || defined(WOLFSSL_KEIL_TCP_NET) || \ 1620 defined(FREESCALE_MQX) 1621 typedef unsigned int THREAD_RETURN; 1622 typedef int THREAD_TYPE; 1623 #define WOLFSSL_THREAD 1624 #elif defined(WOLFSSL_NUCLEUS) 1625 typedef unsigned int THREAD_RETURN; 1626 typedef intptr_t THREAD_TYPE; 1627 #define WOLFSSL_THREAD 1628 #elif defined(WOLFSSL_TIRTOS) 1629 typedef void THREAD_RETURN; 1630 #define WOLFSSL_THREAD_VOID_RETURN 1631 typedef Task_Handle THREAD_TYPE; 1632 #define WOLFSSL_THREAD 1633 #elif defined(WOLFSSL_ZEPHYR) 1634 typedef void THREAD_RETURN; 1635 #define WOLFSSL_THREAD_VOID_RETURN 1636 typedef struct { 1637 /* Zephyr k_thread can be large, > 128 bytes. */ 1638 struct k_thread* tid; 1639 k_thread_stack_t* threadStack; 1640 } THREAD_TYPE; 1641 #define WOLFSSL_THREAD 1642 extern void* wolfsslThreadHeapHint; 1643 #elif defined(NETOS) 1644 typedef UINT THREAD_RETURN; 1645 typedef struct { 1646 TX_THREAD tid; 1647 void* threadStack; 1648 } THREAD_TYPE; 1649 #define WOLFSSL_THREAD 1650 #define INFINITE TX_WAIT_FOREVER 1651 #define WAIT_OBJECT_0 TX_NO_WAIT 1652 #elif defined(WOLFSSL_LINUXKM) 1653 typedef unsigned int THREAD_RETURN; 1654 typedef size_t THREAD_TYPE; 1655 #define WOLFSSL_THREAD 1656 #elif defined(WOLFSSL_PTHREADS) 1657 #if defined(__APPLE__) && MAC_OS_X_VERSION_MIN_REQUIRED >= 1060 \ 1658 && !defined(__ppc__) 1659 #include <dispatch/dispatch.h> 1660 typedef struct COND_TYPE { 1661 wolfSSL_Mutex mutex; 1662 dispatch_semaphore_t cond; 1663 } COND_TYPE; 1664 #else 1665 #include <pthread.h> 1666 typedef struct COND_TYPE { 1667 pthread_mutex_t mutex; 1668 pthread_cond_t cond; 1669 } COND_TYPE; 1670 #endif 1671 typedef void* THREAD_RETURN; 1672 typedef pthread_t THREAD_TYPE; 1673 #define WOLFSSL_COND 1674 #define WOLFSSL_THREAD 1675 #ifndef HAVE_SELFTEST 1676 #define WOLFSSL_THREAD_NO_JOIN 1677 #endif 1678 #elif defined(FREERTOS) && defined(WOLFSSL_ESPIDF) 1679 typedef void* THREAD_RETURN; 1680 typedef pthread_t THREAD_TYPE; 1681 #define WOLFSSL_THREAD 1682 #elif defined(FREERTOS) 1683 typedef unsigned int THREAD_RETURN; 1684 typedef TaskHandle_t THREAD_TYPE; 1685 #define WOLFSSL_THREAD 1686 #elif defined(_WIN32_WCE) 1687 typedef unsigned THREAD_RETURN; 1688 typedef size_t THREAD_TYPE; 1689 typedef struct COND_TYPE { 1690 wolfSSL_Mutex mutex; 1691 HANDLE cond; 1692 } COND_TYPE; 1693 #define WOLFSSL_COND 1694 #define INVALID_THREAD_VAL ((THREAD_TYPE)(INVALID_HANDLE_VALUE)) 1695 #define WOLFSSL_THREAD __stdcall 1696 #define WOLFSSL_THREAD_NO_JOIN __cdecl 1697 #elif defined(USE_WINDOWS_API) 1698 typedef unsigned THREAD_RETURN; 1699 typedef uintptr_t THREAD_TYPE; 1700 typedef struct COND_TYPE { 1701 wolfSSL_Mutex mutex; 1702 HANDLE cond; 1703 } COND_TYPE; 1704 #define WOLFSSL_COND 1705 #define INVALID_THREAD_VAL ((THREAD_TYPE)(INVALID_HANDLE_VALUE)) 1706 #define WOLFSSL_THREAD __stdcall 1707 #if !defined(__MINGW32__) 1708 #define WOLFSSL_THREAD_NO_JOIN __cdecl 1709 #endif 1710 #elif defined(THREADX) 1711 typedef unsigned int THREAD_RETURN; 1712 typedef TX_THREAD THREAD_TYPE; 1713 #define WOLFSSL_THREAD 1714 #else 1715 typedef unsigned int THREAD_RETURN; 1716 typedef size_t THREAD_TYPE; 1717 #define WOLFSSL_THREAD __stdcall 1718 #endif 1719 1720 1721 #ifndef SINGLE_THREADED 1722 /* Necessary headers should already be included. */ 1723 1724 #ifndef INVALID_THREAD_VAL 1725 #define INVALID_THREAD_VAL ((THREAD_TYPE)(-1)) 1726 #endif 1727 1728 #ifndef WOLFSSL_THREAD_VOID_RETURN 1729 #define WOLFSSL_RETURN_FROM_THREAD(x) return (THREAD_RETURN)(x) 1730 #else 1731 #define WOLFSSL_RETURN_FROM_THREAD(x) \ 1732 do { (void)(x); return; } while(0) 1733 #endif 1734 1735 /* List of defines/types and what they mean: 1736 * THREAD_RETURN - return type of a thread callback 1737 * THREAD_TYPE - type that should be passed into thread handling API 1738 * INVALID_THREAD_VAL - a value that THREAD_TYPE can be checked against 1739 * to check if the value is an invalid thread 1740 * WOLFSSL_THREAD - attribute that should be used to declare thread 1741 * callbacks 1742 * WOLFSSL_COND - defined if this system supports signaling 1743 * COND_TYPE - type that should be passed into the signaling API 1744 * WOLFSSL_THREAD_VOID_RETURN - defined if the thread callback has a 1745 * void return 1746 * WOLFSSL_RETURN_FROM_THREAD - define used to correctly return from a 1747 * thread callback 1748 * THREAD_CB - thread callback type for regular threading API 1749 * 1750 * WOLFSSL_THREAD_NO_JOIN - attribute used to declare thread callbacks 1751 * that do not require cleanup 1752 * THREAD_CB_NOJOIN - thread callback type for thread APIs that do not 1753 * require cleanup 1754 * THREAD_RETURN_NOJOIN - return type used to declare thread callbacks 1755 * that do not require cleanup 1756 * RETURN_FROM_THREAD_NOJOIN - define used to correctly return from 1757 * a thread callback that do not require 1758 * cleanup 1759 * 1760 * Other defines/types are specific for the threading implementation 1761 */ 1762 1763 /* Internal wolfSSL threading interface. It does NOT need to be ported 1764 * during initial porting efforts. This is a very basic interface. Some 1765 * areas don't use this interface on purpose as they need more control 1766 * over threads. 1767 * 1768 * It is currently used for: 1769 * - CRL monitor 1770 * - Testing 1771 * - Entropy generation */ 1772 1773 /* We don't support returns from threads */ 1774 typedef THREAD_RETURN (WOLFSSL_THREAD *THREAD_CB)(void* arg); 1775 WOLFSSL_API int wolfSSL_NewThread(THREAD_TYPE* thread, 1776 THREAD_CB cb, void* arg); 1777 #ifdef WOLFSSL_THREAD_NO_JOIN 1778 /* Create a thread that will be automatically cleaned up. We can't 1779 * return a handle/pointer to the new thread because there are no 1780 * guarantees for how long it will be valid. */ 1781 #if defined(WOLFSSL_PTHREADS) 1782 #define THREAD_CB_NOJOIN THREAD_CB 1783 #define THREAD_RETURN_NOJOIN THREAD_RETURN 1784 #define RETURN_FROM_THREAD_NOJOIN(x) \ 1785 WOLFSSL_RETURN_FROM_THREAD(x) 1786 #else 1787 #define THREAD_RETURN_NOJOIN void 1788 typedef THREAD_RETURN_NOJOIN 1789 (WOLFSSL_THREAD_NO_JOIN *THREAD_CB_NOJOIN)(void* arg); 1790 #define RETURN_FROM_THREAD_NOJOIN(x) return 1791 #endif 1792 WOLFSSL_API int wolfSSL_NewThreadNoJoin(THREAD_CB_NOJOIN cb, 1793 void* arg); 1794 #endif 1795 WOLFSSL_API int wolfSSL_JoinThread(THREAD_TYPE thread); 1796 1797 #ifdef WOLFSSL_COND 1798 WOLFSSL_API int wolfSSL_CondInit(COND_TYPE* cond); 1799 WOLFSSL_API int wolfSSL_CondFree(COND_TYPE* cond); 1800 WOLFSSL_API int wolfSSL_CondSignal(COND_TYPE* cond); 1801 WOLFSSL_API int wolfSSL_CondWait(COND_TYPE* cond); 1802 WOLFSSL_API int wolfSSL_CondStart(COND_TYPE* cond); 1803 WOLFSSL_API int wolfSSL_CondEnd(COND_TYPE* cond); 1804 #endif 1805 #else 1806 #define WOLFSSL_RETURN_FROM_THREAD(x) return (THREAD_RETURN)(x) 1807 #endif /* SINGLE_THREADED */ 1808 1809 #if defined(HAVE_STACK_SIZE) 1810 #define EXIT_TEST(ret) return (THREAD_RETURN)((size_t)(ret)) 1811 #else 1812 #define EXIT_TEST(ret) return ret 1813 #endif 1814 1815 1816 #if (defined(__IAR_SYSTEMS_ICC__) && (__IAR_SYSTEMS_ICC__ > 8)) || \ 1817 defined(__GNUC__) 1818 #define WOLFSSL_PACK __attribute__ ((packed)) 1819 #else 1820 #define WOLFSSL_PACK 1821 #endif 1822 1823 #ifndef __GNUC_PREREQ 1824 #if defined(__GNUC__) && defined(__GNUC_MINOR__) 1825 #define __GNUC_PREREQ(maj, min) \ 1826 ((__GNUC__ << 16) + __GNUC_MINOR__ >= ((maj) << 16) + (min)) 1827 #else 1828 #define __GNUC_PREREQ(maj, min) (0) /* not GNUC */ 1829 #endif 1830 #endif 1831 1832 #if defined(__IAR_SYSTEMS_ICC__) || defined(__GNUC__) 1833 #define WC_NORETURN __attribute__((noreturn)) 1834 #else 1835 #define WC_NORETURN 1836 #endif 1837 1838 #if defined(WOLFSSL_KEY_GEN) || defined(HAVE_COMP_KEY) || \ 1839 defined(WOLFSSL_DEBUG_MATH) || defined(DEBUG_WOLFSSL) || \ 1840 defined(WOLFSSL_PUBLIC_MP) || defined(OPENSSL_EXTRA) || \ 1841 (defined(HAVE_ECC) && defined(HAVE_ECC_KEY_EXPORT)) 1842 #undef WC_MP_TO_RADIX 1843 #define WC_MP_TO_RADIX 1844 #endif 1845 1846 #if defined(__GNUC__) && __GNUC__ > 5 1847 #define PRAGMA_GCC_DIAG_PUSH _Pragma("GCC diagnostic push") 1848 #define PRAGMA_GCC(str) _Pragma(str) 1849 #define PRAGMA_GCC_DIAG_POP _Pragma("GCC diagnostic pop") 1850 #define PRAGMA_DIAG_PUSH PRAGMA_GCC_DIAG_PUSH 1851 #define PRAGMA(str) PRAGMA_GCC(str) 1852 #define PRAGMA_DIAG_POP PRAGMA_GCC_DIAG_POP 1853 #else 1854 #define PRAGMA_GCC_DIAG_PUSH /* null expansion */ 1855 #define PRAGMA_GCC(str) /* null expansion */ 1856 #define PRAGMA_GCC_DIAG_POP /* null expansion */ 1857 #endif 1858 1859 #ifdef __clang__ 1860 #define PRAGMA_CLANG_DIAG_PUSH _Pragma("clang diagnostic push") 1861 #define PRAGMA_CLANG(str) _Pragma(str) 1862 #define PRAGMA_CLANG_DIAG_POP _Pragma("clang diagnostic pop") 1863 #define PRAGMA_DIAG_PUSH PRAGMA_CLANG_DIAG_PUSH 1864 #define PRAGMA(str) PRAGMA_CLANG(str) 1865 #define PRAGMA_DIAG_POP PRAGMA_CLANG_DIAG_POP 1866 #else 1867 #define PRAGMA_CLANG_DIAG_PUSH /* null expansion */ 1868 #define PRAGMA_CLANG(str) /* null expansion */ 1869 #define PRAGMA_CLANG_DIAG_POP /* null expansion */ 1870 #endif 1871 1872 #ifndef PRAGMA_DIAG_PUSH 1873 #define PRAGMA_DIAG_PUSH /* null expansion */ 1874 #endif 1875 #ifndef PRAGMA 1876 #define PRAGMA(str) /* null expansion */ 1877 #endif 1878 #ifndef PRAGMA_DIAG_POP 1879 #define PRAGMA_DIAG_POP /* null expansion */ 1880 #endif 1881 1882 #define WC_CPP_CAT4_(a, b, c, d) a ## b ## c ## d 1883 #define WC_CPP_CAT4(a, b, c, d) WC_CPP_CAT4_(a, b, c, d) 1884 #if defined(WC_NO_STATIC_ASSERT) 1885 #define wc_static_assert(expr) struct wc_static_assert_dummy_struct 1886 #define wc_static_assert2(expr, msg) wc_static_assert(expr) 1887 #elif !defined(wc_static_assert) 1888 #if defined(WOLFSSL_HAVE_ASSERT_H) && !defined(WOLFSSL_NO_ASSERT_H) 1889 #include <assert.h> 1890 #endif 1891 #if (defined(__cplusplus) && (__cplusplus >= 201703L)) || \ 1892 (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 202311L)) || \ 1893 (defined(_MSVC_LANG) && (__cpp_static_assert >= 201411L)) 1894 /* native variadic static_assert() */ 1895 #define wc_static_assert static_assert 1896 #ifndef wc_static_assert2 1897 #define wc_static_assert2 static_assert 1898 #endif 1899 #elif (defined(_MSC_VER) && (__STDC_VERSION__ >= 201112L)) || \ 1900 (defined(_MSVC_LANG) && (__cpp_static_assert >= 200410L)) 1901 /* native 2-argument static_assert() */ 1902 #define wc_static_assert(expr) static_assert(expr, #expr) 1903 #ifndef wc_static_assert2 1904 #define wc_static_assert2(expr, msg) static_assert(expr, msg) 1905 #endif 1906 #elif !defined(__cplusplus) && \ 1907 !defined(__STRICT_ANSI__) && \ 1908 !defined(WOLF_C89) && \ 1909 defined(__STDC_VERSION__) && \ 1910 (__STDC_VERSION__ >= 201112L) && \ 1911 ((defined(__GNUC__) && \ 1912 (__GNUC__ >= 5)) || \ 1913 defined(__clang__)) 1914 /* native 2-argument _Static_assert() */ 1915 #define wc_static_assert(expr) _Static_assert(expr, #expr) 1916 #ifndef wc_static_assert2 1917 #define wc_static_assert2(expr, msg) _Static_assert(expr, msg) 1918 #endif 1919 #else 1920 #ifdef __COUNTER__ 1921 #define wc_static_assert(expr) \ 1922 struct WC_CPP_CAT4(wc_static_assert_dummy_struct_L, \ 1923 __LINE__, _, __COUNTER__) { \ 1924 char t[(expr) ? 1 : -1]; \ 1925 } 1926 #else 1927 #define wc_static_assert(expr) \ 1928 struct wc_static_assert_dummy_struct 1929 #endif 1930 #ifndef wc_static_assert2 1931 #define wc_static_assert2(expr, msg) wc_static_assert(expr) 1932 #endif 1933 #endif 1934 #elif !defined(wc_static_assert2) 1935 #define wc_static_assert2(expr, msg) wc_static_assert(expr) 1936 #endif 1937 1938 #ifndef SAVE_VECTOR_REGISTERS 1939 #define SAVE_VECTOR_REGISTERS(fail_clause) WC_DO_NOTHING 1940 #endif 1941 #ifndef SAVE_VECTOR_REGISTERS2 1942 #define SAVE_VECTOR_REGISTERS2() 0 1943 #define SAVE_VECTOR_REGISTERS2_DOES_NOTHING 1944 #endif 1945 #ifndef CAN_SAVE_VECTOR_REGISTERS 1946 #define CAN_SAVE_VECTOR_REGISTERS() 1 1947 #define CAN_SAVE_VECTOR_REGISTERS_ALWAYS_TRUE 1948 #endif 1949 #ifndef WC_DEBUG_SET_VECTOR_REGISTERS_RETVAL 1950 #define WC_DEBUG_SET_VECTOR_REGISTERS_RETVAL(x) WC_DO_NOTHING 1951 #endif 1952 #ifndef ASSERT_SAVED_VECTOR_REGISTERS 1953 #define ASSERT_SAVED_VECTOR_REGISTERS() WC_DO_NOTHING 1954 #endif 1955 #ifndef ASSERT_RESTORED_VECTOR_REGISTERS 1956 #define ASSERT_RESTORED_VECTOR_REGISTERS(fail_clause) WC_DO_NOTHING 1957 #endif 1958 #ifndef RESTORE_VECTOR_REGISTERS 1959 #define RESTORE_VECTOR_REGISTERS() WC_DO_NOTHING 1960 #endif 1961 #ifdef WOLFSSL_NO_ASM 1962 /* We define fallback no-op definitions for these only if asm is disabled, 1963 * otherwise the using code must detect that these macros are undefined and 1964 * provide its own non-vector implementation paths. 1965 * 1966 * Currently these macros are only used in WOLFSSL_LINUXKM code paths, which 1967 * are always compiled either with substantive definitions from 1968 * linuxkm_wc_port.h, or with WOLFSSL_NO_ASM defined. 1969 */ 1970 #ifndef DISABLE_VECTOR_REGISTERS 1971 #define DISABLE_VECTOR_REGISTERS() 0 1972 #endif 1973 #ifndef REENABLE_VECTOR_REGISTERS 1974 #define REENABLE_VECTOR_REGISTERS() WC_DO_NOTHING 1975 #endif 1976 #endif 1977 1978 #ifndef WC_SANITIZE_DISABLE 1979 #define WC_SANITIZE_DISABLE() WC_DO_NOTHING 1980 #endif 1981 #ifndef WC_SANITIZE_ENABLE 1982 #define WC_SANITIZE_ENABLE() WC_DO_NOTHING 1983 #endif 1984 1985 #if FIPS_VERSION_GE(5,1) 1986 #define WC_SPKRE_F(x,y) wolfCrypt_SetPrivateKeyReadEnable_fips((x),(y)) 1987 #define PRIVATE_KEY_LOCK() WC_SPKRE_F(0,WC_KEYTYPE_ALL) 1988 #define PRIVATE_KEY_UNLOCK() WC_SPKRE_F(1,WC_KEYTYPE_ALL) 1989 #else 1990 #define PRIVATE_KEY_LOCK() WC_DO_NOTHING 1991 #define PRIVATE_KEY_UNLOCK() WC_DO_NOTHING 1992 #endif 1993 1994 1995 #ifdef _MSC_VER 1996 /* disable buggy MSC warning (incompatible with clang-tidy 1997 * readability-avoid-const-params-in-decls) 1998 * "warning C4028: formal parameter x different from declaration" 1999 */ 2000 #pragma warning(disable: 4028) 2001 #endif 2002 2003 2004 /* opaque math variable type */ 2005 #if defined(USE_FAST_MATH) 2006 struct fp_int; 2007 #define MATH_INT_T struct fp_int 2008 #elif defined(USE_INTEGER_HEAP_MATH) 2009 struct mp_int; 2010 #define MATH_INT_T struct mp_int 2011 #else 2012 struct sp_int; 2013 #define MATH_INT_T struct sp_int 2014 #endif 2015 2016 2017 /* Maximum ASN sizes */ 2018 #ifndef WOLFSSL_ASN_MAX_LENGTH_SZ 2019 #define WOLFSSL_ASN_MAX_LENGTH_SZ 5 /* 1 byte length + 4 bytes of number */ 2020 #endif 2021 2022 enum Max_ASN { 2023 DSA_PUB_INTS = 4, /* DSA ints in public key */ 2024 DSA_INTS = 5, /* DSA ints in private key */ 2025 MAX_SALT_SIZE = 64, /* MAX PKCS Salt length */ 2026 MAX_IV_SIZE = 64, /* MAX PKCS Iv length */ 2027 #ifdef HAVE_SPHINCS 2028 MAX_ENCODED_SIG_SZ = 51200, 2029 #elif defined(HAVE_FALCON) || defined(HAVE_DILITHIUM) 2030 MAX_ENCODED_SIG_SZ = 5120, 2031 #elif !defined(NO_RSA) 2032 #if defined(USE_FAST_MATH) && defined(FP_MAX_BITS) 2033 MAX_ENCODED_SIG_SZ = FP_MAX_BITS / 8, 2034 #elif (defined(WOLFSSL_SP_MATH_ALL) || defined(WOLFSSL_SP_MATH)) && \ 2035 defined(SP_INT_BITS) 2036 MAX_ENCODED_SIG_SZ = (SP_INT_BITS + 7) / 8, 2037 #elif defined(WOLFSSL_HAPROXY) 2038 MAX_ENCODED_SIG_SZ = 1024, /* Supports 8192 bit keys */ 2039 #else 2040 MAX_ENCODED_SIG_SZ = 512, /* Supports 4096 bit keys */ 2041 #endif 2042 #elif defined(HAVE_ECC) 2043 MAX_ENCODED_SIG_SZ = 140, 2044 #elif defined(HAVE_CURVE448) 2045 MAX_ENCODED_SIG_SZ = 114, 2046 #else 2047 MAX_ENCODED_SIG_SZ = 64, 2048 #endif 2049 MAX_SIG_SZ = 256, 2050 MAX_ALGO_SZ = 20, 2051 MAX_LENGTH_SZ = WOLFSSL_ASN_MAX_LENGTH_SZ, /* Max length size for DER encoding */ 2052 MAX_SHORT_SZ = (1 + 1 + 5), /* asn int + byte len + 5 byte length */ 2053 MAX_SEQ_SZ = (1 + MAX_LENGTH_SZ), /* enum(seq | con) + length(5) */ 2054 MAX_SET_SZ = (1 + MAX_LENGTH_SZ), /* enum(set | con) + length(5) */ 2055 MAX_OCTET_STR_SZ = (1 + MAX_LENGTH_SZ), /* enum(set | con) + length(5) */ 2056 MAX_EXP_SZ = (1 + MAX_LENGTH_SZ), /* enum(contextspec|con|exp) + length(5) */ 2057 MAX_PRSTR_SZ = (1 + MAX_LENGTH_SZ), /* enum(prstr) + length(5) */ 2058 MAX_VERSION_SZ = 5, /* enum + id + version(byte) + (header(2))*/ 2059 MAX_ENCODED_DIG_ASN_SZ = (5 + MAX_LENGTH_SZ), /* enum(bit or octet) + length(5) */ 2060 MAX_ENCODED_DIG_SZ = 64 + MAX_ENCODED_DIG_ASN_SZ, /* asn header + sha512 */ 2061 MAX_RSA_INT_SZ = (512 + 1 + MAX_LENGTH_SZ), /* RSA raw sz 4096 for bits + tag + len(5) */ 2062 MAX_DSA_INT_SZ = (384 + 1 + MAX_LENGTH_SZ), /* DSA raw sz 3072 for bits + tag + len(5) */ 2063 MAX_DSA_PUBKEY_SZ = (DSA_PUB_INTS * MAX_DSA_INT_SZ) + (2 * MAX_SEQ_SZ) + 2064 2 + MAX_LENGTH_SZ, /* Maximum size of a DSA public 2065 key taken from wc_SetDsaPublicKey. */ 2066 MAX_DSA_PRIVKEY_SZ = (DSA_INTS * MAX_DSA_INT_SZ) + MAX_SEQ_SZ + 2067 MAX_VERSION_SZ, /* Maximum size of a DSA Private 2068 key taken from DsaKeyIntsToDer. */ 2069 #if defined(HAVE_FALCON) || defined(HAVE_DILITHIUM) 2070 MAX_PQC_PUBLIC_KEY_SZ = 2592, /* Maximum size of a Dilithium public key. */ 2071 #endif 2072 MAX_RSA_E_SZ = 16, /* Max RSA public e size */ 2073 MAX_CA_SZ = 32, /* Max encoded CA basic constraint length */ 2074 MAX_SN_SZ = 35, /* Max encoded serial number (INT) length */ 2075 MAX_DER_DIGEST_SZ = MAX_ENCODED_DIG_SZ + MAX_ALGO_SZ + MAX_SEQ_SZ, 2076 /* Maximum DER digest size */ 2077 MAX_DER_DIGEST_ASN_SZ = MAX_ENCODED_DIG_ASN_SZ + MAX_ALGO_SZ + MAX_SEQ_SZ, 2078 /* Maximum DER digest ASN header size */ 2079 /* Max X509 header length indicates the 2080 * max length + 2 ('\n', '\0') */ 2081 #if defined(HAVE_FALCON) || defined(HAVE_DILITHIUM) || defined(HAVE_SPHINCS) 2082 MAX_X509_HEADER_SZ = (48 + 2), /* Maximum PEM Header/Footer Size */ 2083 #else 2084 MAX_X509_HEADER_SZ = (37 + 2), /* Maximum PEM Header/Footer Size */ 2085 #endif 2086 2087 #if defined(HAVE_FALCON) || defined(HAVE_DILITHIUM) 2088 MAX_PUBLIC_KEY_SZ = MAX_PQC_PUBLIC_KEY_SZ + MAX_ALGO_SZ + MAX_SEQ_SZ * 2, 2089 #else 2090 MAX_PUBLIC_KEY_SZ = MAX_DSA_PUBKEY_SZ + MAX_ALGO_SZ + MAX_SEQ_SZ * 2, 2091 #endif 2092 #ifdef WOLFSSL_ENCRYPTED_KEYS 2093 HEADER_ENCRYPTED_KEY_SIZE = 88 /* Extra header size for encrypted key */ 2094 #else 2095 HEADER_ENCRYPTED_KEY_SIZE = 0 2096 #endif 2097 }; 2098 2099 #ifndef WC_MAX_DIGEST_SIZE 2100 #define WC_MAX_DIGEST_SIZE 64 2101 #endif 2102 #ifndef WC_MAX_BLOCK_SIZE 2103 #define WC_MAX_BLOCK_SIZE 128 2104 #endif 2105 2106 #ifdef WOLFSSL_CERT_GEN 2107 /* Used in asn.c MakeSignature for ECC and RSA non-blocking/async */ 2108 enum CertSignState { 2109 CERTSIGN_STATE_BEGIN, 2110 CERTSIGN_STATE_DIGEST, 2111 CERTSIGN_STATE_ENCODE, 2112 CERTSIGN_STATE_DO 2113 }; 2114 2115 typedef struct CertSignCtx { 2116 #ifdef WOLFSSL_NO_MALLOC 2117 byte sig[MAX_ENCODED_SIG_SZ]; 2118 byte digest[WC_MAX_DIGEST_SIZE]; 2119 #ifndef NO_RSA 2120 byte encSig[MAX_DER_DIGEST_SZ]; 2121 #endif 2122 #else 2123 byte* sig; 2124 byte* digest; 2125 #ifndef NO_RSA 2126 byte* encSig; 2127 #endif 2128 #endif 2129 2130 #ifndef NO_RSA 2131 int encSigSz; 2132 #endif 2133 int state; /* enum CertSignState */ 2134 } CertSignCtx; 2135 2136 #endif /* WOLFSSL_CERT_GEN */ 2137 2138 2139 #ifdef __cplusplus 2140 } /* extern "C" */ 2141 #endif 2142 2143 #endif /* WOLF_CRYPT_TYPES_H */