1 /* types.h 2 * 3 * Copyright (C) 2006-2021 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 2 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 37 #ifdef __cplusplus 38 extern "C" { 39 #endif 40 41 42 #define WOLFSSL_ABI 43 /* Tag for all the APIs that are a part of the fixed ABI. */ 44 45 /* 46 * This struct is used multiple time by other structs and 47 * needs to be defined somwhere that all structs can import 48 * (with minimal depencencies). 49 */ 50 #ifdef HAVE_EX_DATA 51 #ifdef HAVE_EX_DATA_CLEANUP_HOOKS 52 typedef void (*wolfSSL_ex_data_cleanup_routine_t)(void *data); 53 #endif 54 typedef struct WOLFSSL_CRYPTO_EX_DATA { 55 void* ex_data[MAX_EX_DATA]; 56 #ifdef HAVE_EX_DATA_CLEANUP_HOOKS 57 wolfSSL_ex_data_cleanup_routine_t ex_data_cleanup_routines[MAX_EX_DATA]; 58 #endif 59 } WOLFSSL_CRYPTO_EX_DATA; 60 #endif 61 62 #if defined(WORDS_BIGENDIAN) 63 #define BIG_ENDIAN_ORDER 64 #endif 65 66 #ifndef BIG_ENDIAN_ORDER 67 #define LITTLE_ENDIAN_ORDER 68 #endif 69 70 #ifndef WOLFSSL_TYPES 71 #ifndef byte 72 typedef unsigned char byte; 73 typedef signed char sword8; 74 typedef unsigned char word8; 75 #endif 76 #ifdef WC_16BIT_CPU 77 typedef int sword16; 78 typedef unsigned int word16; 79 typedef long sword32; 80 typedef unsigned long word32; 81 #else 82 typedef short sword16; 83 typedef unsigned short word16; 84 typedef int sword32; 85 typedef unsigned int word32; 86 #endif 87 typedef byte word24[3]; 88 #endif 89 90 91 /* constant pointer to a constant char */ 92 #ifdef WOLFSSL_NO_CONSTCHARCONST 93 typedef const char* wcchar; 94 #else 95 typedef const char* const wcchar; 96 #endif 97 98 #ifndef HAVE_ANONYMOUS_INLINE_AGGREGATES 99 /* if a version is available, pivot on the version, otherwise guess it's 100 * allowed, subject to override. 101 */ 102 #if !defined(__STDC__) \ 103 || (!defined(__STDC_VERSION__) && !defined(__cplusplus)) \ 104 || (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201101L)) \ 105 || (defined(__cplusplus) && (__cplusplus >= 201103L)) 106 #define HAVE_ANONYMOUS_INLINE_AGGREGATES 1 107 #else 108 #define HAVE_ANONYMOUS_INLINE_AGGREGATES 0 109 #endif 110 #endif 111 112 /* helpers for stringifying the expanded value of a macro argument rather 113 * than its literal text: 114 */ 115 #define _WC_STRINGIFY_L2(str) #str 116 #define WC_STRINGIFY(str) _WC_STRINGIFY_L2(str) 117 118 /* try to set SIZEOF_LONG or SIZEOF_LONG_LONG if user didn't */ 119 #if defined(_MSC_VER) || defined(HAVE_LIMITS_H) 120 /* make sure both SIZEOF_LONG_LONG and SIZEOF_LONG are set, 121 * otherwise causes issues with CTC_SETTINGS */ 122 #if !defined(SIZEOF_LONG_LONG) || !defined(SIZEOF_LONG) 123 #include <limits.h> 124 #if !defined(SIZEOF_LONG) && defined(ULONG_MAX) && \ 125 (ULONG_MAX == 0xffffffffUL) 126 #define SIZEOF_LONG 4 127 #endif 128 #if !defined(SIZEOF_LONG_LONG) && defined(ULLONG_MAX) && \ 129 (ULLONG_MAX == 0xffffffffffffffffULL) 130 #define SIZEOF_LONG_LONG 8 131 #endif 132 #endif 133 #elif !defined(__BCPLUSPLUS__) && !defined(__EMSCRIPTEN__) 134 #if !defined(SIZEOF_LONG_LONG) && !defined(SIZEOF_LONG) 135 #if (defined(__alpha__) || defined(__ia64__) || \ 136 defined(_ARCH_PPC64) || defined(__mips64) || \ 137 defined(__x86_64__) || defined(__s390x__ ) || \ 138 ((defined(sun) || defined(__sun)) && \ 139 (defined(LP64) || defined(_LP64)))) 140 /* long should be 64bit */ 141 #define SIZEOF_LONG 8 142 #elif defined(__i386__) || defined(__CORTEX_M3__) 143 /* long long should be 64bit */ 144 #define SIZEOF_LONG_LONG 8 145 #endif 146 #endif 147 #endif 148 149 #if defined(_MSC_VER) || defined(__BCPLUSPLUS__) 150 #define WORD64_AVAILABLE 151 #define W64LIT(x) x##ui64 152 typedef __int64 sword64; 153 typedef unsigned __int64 word64; 154 #elif defined(__EMSCRIPTEN__) 155 #define WORD64_AVAILABLE 156 #define W64LIT(x) x##ull 157 typedef long long sword64; 158 typedef unsigned long long word64; 159 #elif defined(SIZEOF_LONG) && SIZEOF_LONG == 8 160 #define WORD64_AVAILABLE 161 #define W64LIT(x) x##LL 162 typedef long sword64; 163 typedef unsigned long word64; 164 #elif defined(SIZEOF_LONG_LONG) && SIZEOF_LONG_LONG == 8 165 #define WORD64_AVAILABLE 166 #define W64LIT(x) x##LL 167 typedef long long sword64; 168 typedef unsigned long long word64; 169 #elif defined(__SIZEOF_LONG_LONG__) && __SIZEOF_LONG_LONG__ == 8 170 #define WORD64_AVAILABLE 171 #define W64LIT(x) x##LL 172 typedef long long sword64; 173 typedef unsigned long long word64; 174 #endif 175 176 #if defined(WORD64_AVAILABLE) && !defined(WC_16BIT_CPU) 177 /* These platforms have 64-bit CPU registers. */ 178 #if (defined(__alpha__) || defined(__ia64__) || defined(_ARCH_PPC64) || \ 179 defined(__mips64) || defined(__x86_64__) || defined(_M_X64)) || \ 180 defined(__aarch64__) || defined(__sparc64__) || defined(__s390x__ ) || \ 181 (defined(__riscv_xlen) && (__riscv_xlen == 64)) || defined(_M_ARM64) 182 #define WC_64BIT_CPU 183 #elif (defined(sun) || defined(__sun)) && \ 184 (defined(LP64) || defined(_LP64)) 185 /* LP64 with GNU GCC compiler is reserved for when long int is 64 bits 186 * and int uses 32 bits. When using Solaris Studio sparc and __sparc are 187 * available for 32 bit detection but __sparc64__ could be missed. This 188 * uses LP64 for checking 64 bit CPU arch. */ 189 #define WC_64BIT_CPU 190 #else 191 #define WC_32BIT_CPU 192 #endif 193 194 #if defined(NO_64BIT) 195 typedef word32 wolfssl_word; 196 #undef WORD64_AVAILABLE 197 #else 198 #ifdef WC_64BIT_CPU 199 typedef word64 wolfssl_word; 200 #else 201 typedef word32 wolfssl_word; 202 #ifdef WORD64_AVAILABLE 203 #define WOLFCRYPT_SLOW_WORD64 204 #endif 205 #endif 206 #endif 207 208 #elif defined(WC_16BIT_CPU) 209 #undef WORD64_AVAILABLE 210 typedef word16 wolfssl_word; 211 #define MP_16BIT /* for mp_int, mp_word needs to be twice as big as 212 mp_digit, no 64 bit type so make mp_digit 16 bit */ 213 214 #else 215 #undef WORD64_AVAILABLE 216 typedef word32 wolfssl_word; 217 #define MP_16BIT /* for mp_int, mp_word needs to be twice as big as 218 mp_digit, no 64 bit type so make mp_digit 16 bit */ 219 #endif 220 221 #ifdef WC_PTR_TYPE /* Allow user suppied type */ 222 typedef WC_PTR_TYPE wc_ptr_t; 223 #elif defined(HAVE_UINTPTR_T) 224 #include <stdint.h> 225 typedef uintptr_t wc_ptr_t; 226 #else /* fallback to architecture size_t for pointer size */ 227 #include <stddef.h> /* included for getting size_t type */ 228 typedef size_t wc_ptr_t; 229 #endif 230 231 enum { 232 WOLFSSL_WORD_SIZE = sizeof(wolfssl_word), 233 WOLFSSL_BIT_SIZE = 8, 234 WOLFSSL_WORD_BITS = WOLFSSL_WORD_SIZE * WOLFSSL_BIT_SIZE 235 }; 236 237 #define WOLFSSL_MAX_16BIT 0xffffU 238 239 /* use inlining if compiler allows */ 240 #ifndef WC_INLINE 241 #ifndef NO_INLINE 242 #ifdef _MSC_VER 243 #define WC_INLINE __inline 244 #elif defined(__GNUC__) 245 #ifdef WOLFSSL_VXWORKS 246 #define WC_INLINE __inline__ 247 #else 248 #define WC_INLINE inline 249 #endif 250 #elif defined(__IAR_SYSTEMS_ICC__) 251 #define WC_INLINE inline 252 #elif defined(THREADX) 253 #define WC_INLINE _Inline 254 #elif defined(__ghc__) 255 #ifndef __cplusplus 256 #define WC_INLINE __inline 257 #else 258 #define WC_INLINE inline 259 #endif 260 #elif defined(__CCRX__) 261 #define WC_INLINE inline 262 #else 263 #define WC_INLINE 264 #endif 265 #else 266 #ifdef __GNUC__ 267 #define WC_INLINE __attribute__((unused)) 268 #else 269 #define WC_INLINE 270 #endif 271 #endif 272 #endif 273 274 #if defined(HAVE_FIPS) || defined(HAVE_SELFTEST) 275 #define INLINE WC_INLINE 276 #endif 277 278 279 /* set up rotate style */ 280 #if (defined(_MSC_VER) || defined(__BCPLUSPLUS__)) && \ 281 !defined(WOLFSSL_SGX) && !defined(INTIME_RTOS) 282 #define INTEL_INTRINSICS 283 #define FAST_ROTATE 284 #elif defined(__MWERKS__) && TARGET_CPU_PPC 285 #define PPC_INTRINSICS 286 #define FAST_ROTATE 287 #elif defined(__CCRX__) 288 #define FAST_ROTATE 289 #elif defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__)) 290 /* GCC does peephole optimizations which should result in using rotate 291 instructions */ 292 #define FAST_ROTATE 293 #endif 294 295 296 /* set up thread local storage if available */ 297 #ifdef HAVE_THREAD_LS 298 #if defined(_MSC_VER) 299 #define THREAD_LS_T __declspec(thread) 300 /* Thread local storage only in FreeRTOS v8.2.1 and higher */ 301 #elif defined(FREERTOS) || defined(FREERTOS_TCP) || \ 302 defined(WOLFSSL_ZEPHYR) 303 #define THREAD_LS_T 304 #else 305 #define THREAD_LS_T __thread 306 #endif 307 #else 308 #define THREAD_LS_T 309 #endif 310 311 #ifndef FALL_THROUGH 312 /* GCC 7 has new switch() fall-through detection */ 313 #if defined(__GNUC__) 314 #if defined(fallthrough) 315 #define FALL_THROUGH fallthrough 316 #elif ((__GNUC__ > 7) || ((__GNUC__ == 7) && (__GNUC_MINOR__ >= 1))) 317 #define FALL_THROUGH ; __attribute__ ((fallthrough)) 318 #elif defined(__clang__) && defined(__clang_major__) && \ 319 (__clang_major__ >= 12) 320 #define FALL_THROUGH ; __attribute__ ((fallthrough)) 321 #endif 322 #endif 323 #endif /* FALL_THROUGH */ 324 #if !defined(FALL_THROUGH) || defined(__XC32) 325 /* use stub for fall through by default or for Microchip compiler */ 326 #undef FALL_THROUGH 327 #define FALL_THROUGH 328 #endif 329 330 #ifndef WARN_UNUSED_RESULT 331 #if defined(WOLFSSL_LINUXKM) && defined(__must_check) 332 #define WARN_UNUSED_RESULT __must_check 333 #elif defined(__GNUC__) && (__GNUC__ >= 4) 334 #define WARN_UNUSED_RESULT __attribute__((warn_unused_result)) 335 #else 336 #define WARN_UNUSED_RESULT 337 #endif 338 #endif /* WARN_UNUSED_RESULT */ 339 340 #ifndef WC_MAYBE_UNUSED 341 #if (defined(__GNUC__) && (__GNUC__ >= 4)) || defined(__clang__) 342 #define WC_MAYBE_UNUSED __attribute__((unused)) 343 #else 344 #define WC_MAYBE_UNUSED 345 #endif 346 #endif /* WC_MAYBE_UNUSED */ 347 348 /* Micrium will use Visual Studio for compilation but not the Win32 API */ 349 #if defined(_WIN32) && !defined(MICRIUM) && !defined(FREERTOS) && \ 350 !defined(FREERTOS_TCP) && !defined(EBSNET) && \ 351 !defined(WOLFSSL_UTASKER) && !defined(INTIME_RTOS) 352 #define USE_WINDOWS_API 353 #endif 354 355 #define XSTR_SIZEOF(x) (sizeof(x) - 1) /* -1 to not count the null char */ 356 357 /* idea to add global alloc override by Moises Guimaraes */ 358 /* default to libc stuff */ 359 /* XREALLOC is used once in normal math lib, not in fast math lib */ 360 /* XFREE on some embedded systems doesn't like free(0) so test */ 361 #if defined(HAVE_IO_POOL) 362 WOLFSSL_API void* XMALLOC(size_t n, void* heap, int type); 363 WOLFSSL_API void* XREALLOC(void *p, size_t n, void* heap, int type); 364 WOLFSSL_API void XFREE(void *p, void* heap, int type); 365 #elif (defined(WOLFSSL_ASYNC_CRYPT) && defined(HAVE_INTEL_QA)) || \ 366 defined(HAVE_INTEL_QA_SYNC) 367 #ifndef HAVE_INTEL_QA_SYNC 368 #include <wolfssl/wolfcrypt/port/intel/quickassist_mem.h> 369 #undef USE_WOLFSSL_MEMORY 370 #ifdef WOLFSSL_DEBUG_MEMORY 371 #define XMALLOC(s, h, t) IntelQaMalloc((s), (h), (t), __func__, __LINE__) 372 #define XFREE(p, h, t) IntelQaFree((p), (h), (t), __func__, __LINE__) 373 #define XREALLOC(p, n, h, t) IntelQaRealloc((p), (n), (h), (t), __func__, __LINE__) 374 #else 375 #define XMALLOC(s, h, t) IntelQaMalloc((s), (h), (t)) 376 #define XFREE(p, h, t) IntelQaFree((p), (h), (t)) 377 #define XREALLOC(p, n, h, t) IntelQaRealloc((p), (n), (h), (t)) 378 #endif /* WOLFSSL_DEBUG_MEMORY */ 379 #else 380 #include <wolfssl/wolfcrypt/port/intel/quickassist_sync.h> 381 #undef USE_WOLFSSL_MEMORY 382 #ifdef WOLFSSL_DEBUG_MEMORY 383 #define XMALLOC(s, h, t) wc_CryptoCb_IntelQaMalloc((s), (h), (t), __func__, __LINE__) 384 #define XFREE(p, h, t) wc_CryptoCb_IntelQaFree((p), (h), (t), __func__, __LINE__) 385 #define XREALLOC(p, n, h, t) wc_CryptoCb_IntelQaRealloc((p), (n), (h), (t), __func__, __LINE__) 386 #else 387 #define XMALLOC(s, h, t) wc_CryptoCb_IntelQaMalloc((s), (h), (t)) 388 #define XFREE(p, h, t) wc_CryptoCb_IntelQaFree((p), (h), (t)) 389 #define XREALLOC(p, n, h, t) wc_CryptoCb_IntelQaRealloc((p), (n), (h), (t)) 390 #endif /* WOLFSSL_DEBUG_MEMORY */ 391 #endif 392 #elif defined(XMALLOC_USER) 393 /* prototypes for user heap override functions */ 394 #include <stddef.h> /* for size_t */ 395 extern void *XMALLOC(size_t n, void* heap, int type); 396 extern void *XREALLOC(void *p, size_t n, void* heap, int type); 397 extern void XFREE(void *p, void* heap, int type); 398 #elif defined(WOLFSSL_MEMORY_LOG) 399 #define XMALLOC(n, h, t) xmalloc(n, h, t, __func__, __FILE__, __LINE__) 400 #define XREALLOC(p, n, h, t) xrealloc(p, n, h, t, __func__, __FILE__, __LINE__) 401 #define XFREE(p, h, t) xfree(p, h, t, __func__, __FILE__, __LINE__) 402 403 /* prototypes for user heap override functions */ 404 #include <stddef.h> /* for size_t */ 405 #include <stdlib.h> 406 WOLFSSL_API void *xmalloc(size_t n, void* heap, int type, 407 const char* func, const char* file, unsigned int line); 408 WOLFSSL_API void *xrealloc(void *p, size_t n, void* heap, int type, 409 const char* func, const char* file, unsigned int line); 410 WOLFSSL_API void xfree(void *p, void* heap, int type, const char* func, 411 const char* file, unsigned int line); 412 #elif defined(XMALLOC_OVERRIDE) 413 /* override the XMALLOC, XFREE and XREALLOC macros */ 414 #elif defined(WOLFSSL_TELIT_M2MB) 415 /* Telit M2MB SDK requires use m2mb_os API's, not std malloc/free */ 416 /* Use of malloc/free will cause CPU reboot */ 417 #define XMALLOC(s, h, t) ((void)h, (void)t, m2mb_os_malloc((s))) 418 #define XFREE(p, h, t) {void* xp = (p); if((xp)) m2mb_os_free((xp));} 419 #define XREALLOC(p, n, h, t) m2mb_os_realloc((p), (n)) 420 421 #elif defined(NO_WOLFSSL_MEMORY) 422 #ifdef WOLFSSL_NO_MALLOC 423 /* this platform does not support heap use */ 424 #ifdef WOLFSSL_MALLOC_CHECK 425 #include <stdio.h> malloc_check(size_t sz)426 static inline void* malloc_check(size_t sz) { 427 printf("wolfSSL_malloc failed"); 428 return NULL; 429 }; 430 #define XMALLOC(s, h, t) malloc_check((s)) 431 #define XFREE(p, h, t) 432 #define XREALLOC(p, n, h, t) (NULL) 433 #else 434 #define XMALLOC(s, h, t) (NULL) 435 #define XFREE(p, h, t) 436 #define XREALLOC(p, n, h, t) (NULL) 437 #endif 438 #else 439 /* just use plain C stdlib stuff if desired */ 440 #include <stdlib.h> 441 #define XMALLOC(s, h, t) malloc((size_t)(s)) 442 #define XFREE(p, h, t) {void* xp = (p); if((xp)) free((xp));} 443 #define XREALLOC(p, n, h, t) realloc((p), (size_t)(n)) 444 #endif 445 446 #elif defined(WOLFSSL_LINUXKM) 447 /* the requisite linux/slab.h is included in wc_port.h, with incompatible warnings masked out. */ 448 #define XMALLOC(s, h, t) ({(void)(h); (void)(t); kmalloc(s, GFP_KERNEL);}) 449 #define XFREE(p, h, t) ({void* _xp; (void)(h); _xp = (p); if(_xp) kfree(_xp);}) 450 #define XREALLOC(p, n, h, t) ({(void)(h); (void)(t); krealloc((p), (n), GFP_KERNEL);}) 451 452 #elif !defined(MICRIUM_MALLOC) && !defined(EBSNET) \ 453 && !defined(WOLFSSL_SAFERTOS) && !defined(FREESCALE_MQX) \ 454 && !defined(FREESCALE_KSDK_MQX) && !defined(FREESCALE_FREE_RTOS) \ 455 && !defined(WOLFSSL_LEANPSK) && !defined(WOLFSSL_uITRON4) 456 /* default C runtime, can install different routines at runtime via cbs */ 457 #ifndef WOLFSSL_MEMORY_H 458 #include <wolfssl/wolfcrypt/memory.h> 459 #endif 460 #ifdef WOLFSSL_STATIC_MEMORY 461 #ifdef WOLFSSL_DEBUG_MEMORY 462 #define XMALLOC(s, h, t) wolfSSL_Malloc((s), (h), (t), __func__, __LINE__) 463 #define XFREE(p, h, t) {void* xp = (p); if((xp)) wolfSSL_Free((xp), (h), (t), __func__, __LINE__);} 464 #define XREALLOC(p, n, h, t) wolfSSL_Realloc((p), (n), (h), (t), __func__, __LINE__) 465 #else 466 #define XMALLOC(s, h, t) wolfSSL_Malloc((s), (h), (t)) 467 #define XFREE(p, h, t) {void* xp = (p); if((xp)) wolfSSL_Free((xp), (h), (t));} 468 #define XREALLOC(p, n, h, t) wolfSSL_Realloc((p), (n), (h), (t)) 469 #endif /* WOLFSSL_DEBUG_MEMORY */ 470 #elif !defined(FREERTOS) && !defined(FREERTOS_TCP) 471 #ifdef WOLFSSL_DEBUG_MEMORY 472 #define XMALLOC(s, h, t) ((void)(h), (void)(t), wolfSSL_Malloc((s), __func__, __LINE__)) 473 #define XFREE(p, h, t) {void* xp = (p); if((xp)) wolfSSL_Free((xp), __func__, __LINE__);} 474 #define XREALLOC(p, n, h, t) wolfSSL_Realloc((p), (n), __func__, __LINE__) 475 #else 476 #define XMALLOC(s, h, t) ((void)(h), (void)(t), wolfSSL_Malloc((s))) 477 #define XFREE(p, h, t) {void* xp = (p); if((xp)) wolfSSL_Free((xp));} 478 #define XREALLOC(p, n, h, t) wolfSSL_Realloc((p), (n)) 479 #endif /* WOLFSSL_DEBUG_MEMORY */ 480 #endif /* WOLFSSL_STATIC_MEMORY */ 481 #endif 482 483 /* declare/free variable handling for async and smallstack */ 484 #if defined(WOLFSSL_ASYNC_CRYPT) || defined(WOLFSSL_SMALL_STACK) 485 #define WC_DECLARE_VAR_IS_HEAP_ALLOC 486 #define WC_DECLARE_VAR(VAR_NAME, VAR_TYPE, VAR_SIZE, HEAP) \ 487 VAR_TYPE* VAR_NAME = (VAR_TYPE*)XMALLOC(sizeof(VAR_TYPE) * VAR_SIZE, (HEAP), DYNAMIC_TYPE_WOLF_BIGINT) 488 #define WC_DECLARE_ARRAY(VAR_NAME, VAR_TYPE, VAR_ITEMS, VAR_SIZE, HEAP) \ 489 VAR_TYPE* VAR_NAME[VAR_ITEMS]; \ 490 int idx##VAR_NAME, inner_idx_##VAR_NAME; \ 491 for (idx##VAR_NAME=0; idx##VAR_NAME<VAR_ITEMS; idx##VAR_NAME++) { \ 492 VAR_NAME[idx##VAR_NAME] = (VAR_TYPE*)XMALLOC(VAR_SIZE, (HEAP), DYNAMIC_TYPE_WOLF_BIGINT); \ 493 if (VAR_NAME[idx##VAR_NAME] == NULL) { \ 494 for (inner_idx_##VAR_NAME = 0; inner_idx_##VAR_NAME < idx##VAR_NAME; inner_idx_##VAR_NAME++) { \ 495 XFREE(VAR_NAME[inner_idx_##VAR_NAME], HEAP, DYNAMIC_TYPE_WOLF_BIGINT); \ 496 VAR_NAME[inner_idx_##VAR_NAME] = NULL; \ 497 } \ 498 for (inner_idx_##VAR_NAME = idx##VAR_NAME + 1; inner_idx_##VAR_NAME < VAR_ITEMS; inner_idx_##VAR_NAME++) { \ 499 VAR_NAME[inner_idx_##VAR_NAME] = NULL; \ 500 } \ 501 break; \ 502 } \ 503 } 504 #define WC_FREE_VAR(VAR_NAME, HEAP) \ 505 XFREE(VAR_NAME, (HEAP), DYNAMIC_TYPE_WOLF_BIGINT) 506 #define WC_FREE_ARRAY(VAR_NAME, VAR_ITEMS, HEAP) \ 507 for (idx##VAR_NAME=0; idx##VAR_NAME<VAR_ITEMS; idx##VAR_NAME++) { \ 508 XFREE(VAR_NAME[idx##VAR_NAME], (HEAP), DYNAMIC_TYPE_WOLF_BIGINT); \ 509 } 510 511 #define WC_DECLARE_ARRAY_DYNAMIC_DEC(VAR_NAME, VAR_TYPE, VAR_ITEMS, VAR_SIZE, HEAP) \ 512 WC_DECLARE_ARRAY(VAR_NAME, VAR_TYPE, VAR_ITEMS, VAR_SIZE, HEAP) 513 #define WC_DECLARE_ARRAY_DYNAMIC_EXE(VAR_NAME, VAR_TYPE, VAR_ITEMS, VAR_SIZE, HEAP) 514 #define WC_FREE_ARRAY_DYNAMIC(VAR_NAME, VAR_ITEMS, HEAP) \ 515 WC_FREE_ARRAY(VAR_NAME, VAR_ITEMS, HEAP) 516 #else 517 #undef WC_DECLARE_VAR_IS_HEAP_ALLOC 518 #define WC_DECLARE_VAR(VAR_NAME, VAR_TYPE, VAR_SIZE, HEAP) \ 519 VAR_TYPE VAR_NAME[VAR_SIZE] 520 #define WC_DECLARE_ARRAY(VAR_NAME, VAR_TYPE, VAR_ITEMS, VAR_SIZE, HEAP) \ 521 VAR_TYPE VAR_NAME[VAR_ITEMS][VAR_SIZE] 522 #define WC_FREE_VAR(VAR_NAME, HEAP) /* nothing to free, its stack */ 523 #define WC_FREE_ARRAY(VAR_NAME, VAR_ITEMS, HEAP) /* nothing to free, its stack */ 524 525 #define WC_DECLARE_ARRAY_DYNAMIC_DEC(VAR_NAME, VAR_TYPE, VAR_ITEMS, VAR_SIZE, HEAP) \ 526 VAR_TYPE* VAR_NAME[VAR_ITEMS]; \ 527 int idx##VAR_NAME, inner_idx_##VAR_NAME; 528 #define WC_DECLARE_ARRAY_DYNAMIC_EXE(VAR_NAME, VAR_TYPE, VAR_ITEMS, VAR_SIZE, HEAP) \ 529 for (idx##VAR_NAME=0; idx##VAR_NAME<VAR_ITEMS; idx##VAR_NAME++) { \ 530 VAR_NAME[idx##VAR_NAME] = (VAR_TYPE*)XMALLOC(VAR_SIZE, (HEAP), DYNAMIC_TYPE_TMP_BUFFER); \ 531 if (VAR_NAME[idx##VAR_NAME] == NULL) { \ 532 for (inner_idx_##VAR_NAME = 0; inner_idx_##VAR_NAME < idx##VAR_NAME; inner_idx_##VAR_NAME++) { \ 533 XFREE(VAR_NAME[inner_idx_##VAR_NAME], HEAP, DYNAMIC_TYPE_TMP_BUFFER); \ 534 VAR_NAME[inner_idx_##VAR_NAME] = NULL; \ 535 } \ 536 for (inner_idx_##VAR_NAME = idx##VAR_NAME + 1; inner_idx_##VAR_NAME < VAR_ITEMS; inner_idx_##VAR_NAME++) { \ 537 VAR_NAME[inner_idx_##VAR_NAME] = NULL; \ 538 } \ 539 break; \ 540 } \ 541 } 542 #define WC_FREE_ARRAY_DYNAMIC(VAR_NAME, VAR_ITEMS, HEAP) \ 543 for (idx##VAR_NAME=0; idx##VAR_NAME<VAR_ITEMS; idx##VAR_NAME++) { \ 544 XFREE(VAR_NAME[idx##VAR_NAME], (HEAP), DYNAMIC_TYPE_TMP_BUFFER); \ 545 } 546 #endif 547 548 #if defined(HAVE_FIPS) || defined(HAVE_SELFTEST) 549 /* These are here for the FIPS code that can't be changed. New definitions don't need to be added here. */ 550 #define DECLARE_VAR WC_DECLARE_VAR 551 #define DECLARE_ARRAY WC_DECLARE_ARRAY 552 #define FREE_VAR WC_FREE_VAR 553 #define FREE_ARRAY WC_FREE_ARRAY 554 #define DECLARE_ARRAY_DYNAMIC_DEC WC_DECLARE_ARRAY_DYNAMIC_DEC 555 #define DECLARE_ARRAY_DYNAMIC_EXE WC_DECLARE_ARRAY_DYNAMIC_EXE 556 #define FREE_ARRAY_DYNAMIC WC_FREE_ARRAY_DYNAMIC 557 #endif /* HAVE_FIPS */ 558 559 #if !defined(USE_WOLF_STRTOK) && \ 560 ((defined(__MINGW32__) && !defined(__MINGW64_VERSION_MAJOR)) || \ 561 defined(WOLFSSL_TIRTOS) || defined(WOLF_C99)) 562 #define USE_WOLF_STRTOK 563 #endif 564 #if !defined(USE_WOLF_STRSEP) && (defined(WOLF_C99)) 565 #define USE_WOLF_STRSEP 566 #endif 567 568 #ifndef STRING_USER 569 #if defined(WOLFSSL_LINUXKM) 570 #include <linux/string.h> 571 #else 572 #include <string.h> 573 #endif 574 575 #define XMEMCPY(d,s,l) memcpy((d),(s),(l)) 576 #define XMEMSET(b,c,l) memset((b),(c),(l)) 577 #define XMEMCMP(s1,s2,n) memcmp((s1),(s2),(n)) 578 #define XMEMMOVE(d,s,l) memmove((d),(s),(l)) 579 580 #define XSTRLEN(s1) strlen((s1)) 581 #define XSTRNCPY(s1,s2,n) strncpy((s1),(s2),(n)) 582 /* strstr, strncmp, strcmp, and strncat only used by wolfSSL proper, 583 * not required for wolfCrypt only */ 584 #define XSTRSTR(s1,s2) strstr((s1),(s2)) 585 #define XSTRNSTR(s1,s2,n) mystrnstr((s1),(s2),(n)) 586 #define XSTRNCMP(s1,s2,n) strncmp((s1),(s2),(n)) 587 #define XSTRCMP(s1,s2) strcmp((s1),(s2)) 588 #define XSTRNCAT(s1,s2,n) strncat((s1),(s2),(n)) 589 590 #ifdef USE_WOLF_STRSEP 591 #define XSTRSEP(s1,d) wc_strsep((s1),(d)) 592 #else 593 #define XSTRSEP(s1,d) strsep((s1),(d)) 594 #endif 595 596 #ifndef XSTRNCASECMP 597 #if defined(MICROCHIP_PIC32) || defined(WOLFSSL_TIRTOS) || \ 598 defined(WOLFSSL_ZEPHYR) 599 /* XC32 does not support strncasecmp, so use case sensitive one */ 600 #define XSTRNCASECMP(s1,s2,n) strncmp((s1),(s2),(n)) 601 #elif defined(USE_WINDOWS_API) || defined(FREERTOS_TCP_WINSIM) 602 #define XSTRNCASECMP(s1,s2,n) _strnicmp((s1),(s2),(n)) 603 #else 604 #if defined(HAVE_STRINGS_H) && defined(WOLF_C99) && \ 605 !defined(WOLFSSL_SGX) 606 #include <strings.h> 607 #endif 608 #if defined(WOLFSSL_DEOS) 609 #define XSTRNCASECMP(s1,s2,n) strnicmp((s1),(s2),(n)) 610 #elif defined(WOLFSSL_CMSIS_RTOSv2) 611 #define XSTRNCASECMP(s1,s2,n) strncmp((s1),(s2),(n)) 612 #else 613 #define XSTRNCASECMP(s1,s2,n) strncasecmp((s1),(s2),(n)) 614 #endif 615 #endif 616 #endif /* !XSTRNCASECMP */ 617 618 /* snprintf is used in asn.c for GetTimeString, PKCS7 test, and when 619 debugging is turned on */ 620 #ifndef USE_WINDOWS_API 621 #ifndef XSNPRINTF 622 #if defined(NO_FILESYSTEM) && !defined(NO_STDIO_FILESYSTEM) && \ 623 (defined(OPENSSL_EXTRA) || defined(OPENSSL_EXTRA_X509_SMALL) || \ 624 defined(WOLFSSL_CERT_EXT) || defined(HAVE_PKCS7)) 625 /* case where stdio is not included else where but is needed 626 for snprintf */ 627 #include <stdio.h> 628 #endif 629 #if defined(WOLFSSL_ESPIDF) && \ 630 (!defined(NO_ASN_TIME) && defined(HAVE_PKCS7)) 631 #include<stdarg.h> 632 /* later gcc than 7.1 introduces -Wformat-truncation */ 633 /* In cases when truncation is expected the caller needs*/ 634 /* to check the return value from the function so that */ 635 /* compiler doesn't complain. */ 636 /* xtensa-esp32-elf v8.2.0 warns trancation at */ 637 /* GetAsnTimeString() */ 638 static WC_INLINE _xsnprintf_(char * s,size_t n,const char * format,...)639 int _xsnprintf_(char *s, size_t n, const char *format, ...) 640 { 641 va_list ap; 642 int ret; 643 644 if ((int)n <= 0) return -1; 645 646 va_start(ap, format); 647 648 ret = XVSNPRINTF(s, n, format, ap); 649 if (ret < 0) 650 ret = -1; 651 652 va_end(ap); 653 654 return ret; 655 } 656 #define XSNPRINTF _xsnprintf_ 657 #else 658 #define XSNPRINTF snprintf 659 #endif 660 #endif 661 #else 662 #if defined(_MSC_VER) || defined(__CYGWIN__) || defined(__MINGW32__) 663 #if defined(_MSC_VER) && (_MSC_VER >= 1900) 664 /* Beginning with the UCRT in Visual Studio 2015 and 665 Windows 10, snprintf is no longer identical to 666 _snprintf. The snprintf function behavior is now 667 C99 standard compliant. */ 668 #include <stdio.h> 669 #define XSNPRINTF snprintf 670 #else 671 /* 4996 warning to use MS extensions e.g., _sprintf_s 672 instead of _snprintf */ 673 #if !defined(__MINGW32__) 674 #pragma warning(disable: 4996) 675 #endif 676 static WC_INLINE xsnprintf(char * buffer,size_t bufsize,const char * format,...)677 int xsnprintf(char *buffer, size_t bufsize, 678 const char *format, ...) { 679 va_list ap; 680 int ret; 681 682 if ((int)bufsize <= 0) return -1; 683 va_start(ap, format); 684 ret = XVSNPRINTF(buffer, bufsize, format, ap); 685 if (ret >= (int)bufsize) 686 ret = -1; 687 va_end(ap); 688 return ret; 689 } 690 #define XSNPRINTF xsnprintf 691 #endif /* (_MSC_VER >= 1900) */ 692 #else 693 #define XSNPRINTF snprintf 694 #endif /* _MSC_VER */ 695 #endif /* USE_WINDOWS_API */ 696 697 #if defined(WOLFSSL_CERT_EXT) || defined(OPENSSL_EXTRA) \ 698 || defined(HAVE_ALPN) 699 /* use only Thread Safe version of strtok */ 700 #if defined(USE_WOLF_STRTOK) 701 #define XSTRTOK(s1,d,ptr) wc_strtok((s1),(d),(ptr)) 702 #elif defined(USE_WINDOWS_API) || defined(INTIME_RTOS) 703 #define XSTRTOK(s1,d,ptr) strtok_s((s1),(d),(ptr)) 704 #else 705 #define XSTRTOK(s1,d,ptr) strtok_r((s1),(d),(ptr)) 706 #endif 707 #endif 708 709 #if defined(WOLFSSL_CERT_EXT) || defined(HAVE_OCSP) || \ 710 defined(HAVE_CRL_IO) || defined(HAVE_HTTP_CLIENT) || \ 711 !defined(NO_CRYPT_BENCHMARK) 712 713 #ifndef XATOI /* if custom XATOI is not already defined */ 714 #include <stdlib.h> 715 #define XATOI(s) atoi((s)) 716 #endif 717 #endif 718 #endif 719 720 #ifdef USE_WOLF_STRTOK 721 WOLFSSL_API char* wc_strtok(char *str, const char *delim, char **nextp); 722 #endif 723 #ifdef USE_WOLF_STRSEP 724 WOLFSSL_API char* wc_strsep(char **stringp, const char *delim); 725 #endif 726 727 #if !defined(NO_FILESYSTEM) && defined(OPENSSL_EXTRA) && \ 728 !defined(NO_STDIO_FILESYSTEM) 729 #ifndef XGETENV 730 #include <stdlib.h> 731 #define XGETENV getenv 732 #endif 733 #endif /* OPENSSL_EXTRA */ 734 735 #ifndef CTYPE_USER 736 #ifndef WOLFSSL_LINUXKM 737 #include <ctype.h> 738 #endif 739 #if defined(HAVE_ECC) || defined(HAVE_OCSP) || \ 740 defined(WOLFSSL_KEY_GEN) || !defined(NO_DSA) || \ 741 defined(OPENSSL_EXTRA) 742 #define XTOUPPER(c) toupper((c)) 743 #endif 744 #ifdef OPENSSL_ALL 745 #define XISALNUM(c) isalnum((c)) 746 #define XISASCII(c) isascii((c)) 747 #define XISSPACE(c) isspace((c)) 748 #endif 749 /* needed by wolfSSL_check_domain_name() */ 750 #define XTOLOWER(c) tolower((c)) 751 #endif 752 753 #ifndef OFFSETOF 754 #if defined(__clang__) || defined(__GNUC__) 755 #define OFFSETOF(type, field) __builtin_offsetof(type, field) 756 #else 757 #define OFFSETOF(type, field) ((size_t)&(((type *)0)->field)) 758 #endif 759 #endif 760 761 762 /* memory allocation types for user hints */ 763 enum { 764 DYNAMIC_TYPE_CA = 1, 765 DYNAMIC_TYPE_CERT = 2, 766 DYNAMIC_TYPE_KEY = 3, 767 DYNAMIC_TYPE_FILE = 4, 768 DYNAMIC_TYPE_SUBJECT_CN = 5, 769 DYNAMIC_TYPE_PUBLIC_KEY = 6, 770 DYNAMIC_TYPE_SIGNER = 7, 771 DYNAMIC_TYPE_NONE = 8, 772 DYNAMIC_TYPE_BIGINT = 9, 773 DYNAMIC_TYPE_RSA = 10, 774 DYNAMIC_TYPE_METHOD = 11, 775 DYNAMIC_TYPE_OUT_BUFFER = 12, 776 DYNAMIC_TYPE_IN_BUFFER = 13, 777 DYNAMIC_TYPE_INFO = 14, 778 DYNAMIC_TYPE_DH = 15, 779 DYNAMIC_TYPE_DOMAIN = 16, 780 DYNAMIC_TYPE_SSL = 17, 781 DYNAMIC_TYPE_CTX = 18, 782 DYNAMIC_TYPE_WRITEV = 19, 783 DYNAMIC_TYPE_OPENSSL = 20, 784 DYNAMIC_TYPE_DSA = 21, 785 DYNAMIC_TYPE_CRL = 22, 786 DYNAMIC_TYPE_REVOKED = 23, 787 DYNAMIC_TYPE_CRL_ENTRY = 24, 788 DYNAMIC_TYPE_CERT_MANAGER = 25, 789 DYNAMIC_TYPE_CRL_MONITOR = 26, 790 DYNAMIC_TYPE_OCSP_STATUS = 27, 791 DYNAMIC_TYPE_OCSP_ENTRY = 28, 792 DYNAMIC_TYPE_ALTNAME = 29, 793 DYNAMIC_TYPE_SUITES = 30, 794 DYNAMIC_TYPE_CIPHER = 31, 795 DYNAMIC_TYPE_RNG = 32, 796 DYNAMIC_TYPE_ARRAYS = 33, 797 DYNAMIC_TYPE_DTLS_POOL = 34, 798 DYNAMIC_TYPE_SOCKADDR = 35, 799 DYNAMIC_TYPE_LIBZ = 36, 800 DYNAMIC_TYPE_ECC = 37, 801 DYNAMIC_TYPE_TMP_BUFFER = 38, 802 DYNAMIC_TYPE_DTLS_MSG = 39, 803 DYNAMIC_TYPE_X509 = 40, 804 DYNAMIC_TYPE_TLSX = 41, 805 DYNAMIC_TYPE_OCSP = 42, 806 DYNAMIC_TYPE_SIGNATURE = 43, 807 DYNAMIC_TYPE_HASHES = 44, 808 DYNAMIC_TYPE_SRP = 45, 809 DYNAMIC_TYPE_COOKIE_PWD = 46, 810 DYNAMIC_TYPE_USER_CRYPTO = 47, 811 DYNAMIC_TYPE_OCSP_REQUEST = 48, 812 DYNAMIC_TYPE_X509_EXT = 49, 813 DYNAMIC_TYPE_X509_STORE = 50, 814 DYNAMIC_TYPE_X509_CTX = 51, 815 DYNAMIC_TYPE_URL = 52, 816 DYNAMIC_TYPE_DTLS_FRAG = 53, 817 DYNAMIC_TYPE_DTLS_BUFFER = 54, 818 DYNAMIC_TYPE_SESSION_TICK = 55, 819 DYNAMIC_TYPE_PKCS = 56, 820 DYNAMIC_TYPE_MUTEX = 57, 821 DYNAMIC_TYPE_PKCS7 = 58, 822 DYNAMIC_TYPE_AES_BUFFER = 59, 823 DYNAMIC_TYPE_WOLF_BIGINT = 60, 824 DYNAMIC_TYPE_ASN1 = 61, 825 DYNAMIC_TYPE_LOG = 62, 826 DYNAMIC_TYPE_WRITEDUP = 63, 827 DYNAMIC_TYPE_PRIVATE_KEY = 64, 828 DYNAMIC_TYPE_HMAC = 65, 829 DYNAMIC_TYPE_ASYNC = 66, 830 DYNAMIC_TYPE_ASYNC_NUMA = 67, 831 DYNAMIC_TYPE_ASYNC_NUMA64 = 68, 832 DYNAMIC_TYPE_CURVE25519 = 69, 833 DYNAMIC_TYPE_ED25519 = 70, 834 DYNAMIC_TYPE_SECRET = 71, 835 DYNAMIC_TYPE_DIGEST = 72, 836 DYNAMIC_TYPE_RSA_BUFFER = 73, 837 DYNAMIC_TYPE_DCERT = 74, 838 DYNAMIC_TYPE_STRING = 75, 839 DYNAMIC_TYPE_PEM = 76, 840 DYNAMIC_TYPE_DER = 77, 841 DYNAMIC_TYPE_CERT_EXT = 78, 842 DYNAMIC_TYPE_ALPN = 79, 843 DYNAMIC_TYPE_ENCRYPTEDINFO= 80, 844 DYNAMIC_TYPE_DIRCTX = 81, 845 DYNAMIC_TYPE_HASHCTX = 82, 846 DYNAMIC_TYPE_SEED = 83, 847 DYNAMIC_TYPE_SYMMETRIC_KEY= 84, 848 DYNAMIC_TYPE_ECC_BUFFER = 85, 849 DYNAMIC_TYPE_SALT = 87, 850 DYNAMIC_TYPE_HASH_TMP = 88, 851 DYNAMIC_TYPE_BLOB = 89, 852 DYNAMIC_TYPE_NAME_ENTRY = 90, 853 DYNAMIC_TYPE_CURVE448 = 91, 854 DYNAMIC_TYPE_ED448 = 92, 855 DYNAMIC_TYPE_AES = 93, 856 DYNAMIC_TYPE_CMAC = 94, 857 DYNAMIC_TYPE_FALCON = 95, 858 DYNAMIC_TYPE_SESSION = 96, 859 DYNAMIC_TYPE_SNIFFER_SERVER = 1000, 860 DYNAMIC_TYPE_SNIFFER_SESSION = 1001, 861 DYNAMIC_TYPE_SNIFFER_PB = 1002, 862 DYNAMIC_TYPE_SNIFFER_PB_BUFFER = 1003, 863 DYNAMIC_TYPE_SNIFFER_TICKET_ID = 1004, 864 DYNAMIC_TYPE_SNIFFER_NAMED_KEY = 1005, 865 }; 866 867 /* max error buffer string size */ 868 #ifndef WOLFSSL_MAX_ERROR_SZ 869 #define WOLFSSL_MAX_ERROR_SZ 80 870 #endif 871 872 /* stack protection */ 873 enum { 874 MIN_STACK_BUFFER = 8 875 }; 876 877 878 /* Algorithm Types */ 879 enum wc_AlgoType { 880 WC_ALGO_TYPE_NONE = 0, 881 WC_ALGO_TYPE_HASH = 1, 882 WC_ALGO_TYPE_CIPHER = 2, 883 WC_ALGO_TYPE_PK = 3, 884 WC_ALGO_TYPE_RNG = 4, 885 WC_ALGO_TYPE_SEED = 5, 886 WC_ALGO_TYPE_HMAC = 6, 887 WC_ALGO_TYPE_CMAC = 7, 888 889 WC_ALGO_TYPE_MAX = WC_ALGO_TYPE_CMAC 890 }; 891 892 /* hash types */ 893 enum wc_HashType { 894 #if defined(HAVE_SELFTEST) || (defined(HAVE_FIPS) && \ 895 ((! defined(HAVE_FIPS_VERSION)) || \ 896 defined(HAVE_FIPS_VERSION) && (HAVE_FIPS_VERSION <= 2))) 897 /* In selftest build, WC_* types are not mapped to WC_HASH_TYPE types. 898 * Values here are based on old selftest hmac.h enum, with additions. 899 * These values are fixed for backwards FIPS compatibility */ 900 WC_HASH_TYPE_NONE = 15, 901 WC_HASH_TYPE_MD2 = 16, 902 WC_HASH_TYPE_MD4 = 17, 903 WC_HASH_TYPE_MD5 = 0, 904 WC_HASH_TYPE_SHA = 1, /* SHA-1 (not old SHA-0) */ 905 WC_HASH_TYPE_SHA224 = 8, 906 WC_HASH_TYPE_SHA256 = 2, 907 WC_HASH_TYPE_SHA384 = 5, 908 WC_HASH_TYPE_SHA512 = 4, 909 WC_HASH_TYPE_MD5_SHA = 18, 910 WC_HASH_TYPE_SHA3_224 = 10, 911 WC_HASH_TYPE_SHA3_256 = 11, 912 WC_HASH_TYPE_SHA3_384 = 12, 913 WC_HASH_TYPE_SHA3_512 = 13, 914 WC_HASH_TYPE_BLAKE2B = 14, 915 WC_HASH_TYPE_BLAKE2S = 19, 916 WC_HASH_TYPE_MAX = WC_HASH_TYPE_BLAKE2S 917 #ifndef WOLFSSL_NOSHA512_224 918 #define WOLFSSL_NOSHA512_224 919 #endif 920 #ifndef WOLFSSL_NOSHA512_256 921 #define WOLFSSL_NOSHA512_256 922 #endif 923 #ifndef WOLFSSL_NO_SHAKE256 924 #define WOLFSSL_NO_SHAKE256 925 #endif 926 #else 927 WC_HASH_TYPE_NONE = 0, 928 WC_HASH_TYPE_MD2 = 1, 929 WC_HASH_TYPE_MD4 = 2, 930 WC_HASH_TYPE_MD5 = 3, 931 WC_HASH_TYPE_SHA = 4, /* SHA-1 (not old SHA-0) */ 932 WC_HASH_TYPE_SHA224 = 5, 933 WC_HASH_TYPE_SHA256 = 6, 934 WC_HASH_TYPE_SHA384 = 7, 935 WC_HASH_TYPE_SHA512 = 8, 936 WC_HASH_TYPE_MD5_SHA = 9, 937 WC_HASH_TYPE_SHA3_224 = 10, 938 WC_HASH_TYPE_SHA3_256 = 11, 939 WC_HASH_TYPE_SHA3_384 = 12, 940 WC_HASH_TYPE_SHA3_512 = 13, 941 WC_HASH_TYPE_BLAKE2B = 14, 942 WC_HASH_TYPE_BLAKE2S = 15, 943 #define _WC_HASH_TYPE_MAX WC_HASH_TYPE_BLAKE2S 944 #ifndef WOLFSSL_NOSHA512_224 945 WC_HASH_TYPE_SHA512_224 = 16, 946 #undef _WC_HASH_TYPE_MAX 947 #define _WC_HASH_TYPE_MAX WC_HASH_TYPE_SHA512_224 948 #endif 949 #ifndef WOLFSSL_NOSHA512_256 950 WC_HASH_TYPE_SHA512_256 = 17, 951 #undef _WC_HASH_TYPE_MAX 952 #define _WC_HASH_TYPE_MAX WC_HASH_TYPE_SHA512_256 953 #endif 954 #ifndef WOLFSSL_NO_SHAKE256 955 WC_HASH_TYPE_SHAKE128 = 18, 956 WC_HASH_TYPE_SHAKE256 = 19, 957 #undef _WC_HASH_TYPE_MAX 958 #define _WC_HASH_TYPE_MAX WC_HASH_TYPE_SHAKE256 959 #endif 960 WC_HASH_TYPE_MAX = _WC_HASH_TYPE_MAX 961 #undef _WC_HASH_TYPE_MAX 962 963 #endif /* HAVE_SELFTEST */ 964 }; 965 966 /* cipher types */ 967 enum wc_CipherType { 968 WC_CIPHER_NONE = 0, 969 WC_CIPHER_AES = 1, 970 WC_CIPHER_AES_CBC = 2, 971 WC_CIPHER_AES_GCM = 3, 972 WC_CIPHER_AES_CTR = 4, 973 WC_CIPHER_AES_XTS = 5, 974 WC_CIPHER_AES_CFB = 6, 975 WC_CIPHER_AES_CCM = 12, 976 WC_CIPHER_DES3 = 7, 977 WC_CIPHER_DES = 8, 978 WC_CIPHER_CHACHA = 9, 979 WC_CIPHER_HC128 = 10, 980 WC_CIPHER_IDEA = 11, 981 982 WC_CIPHER_MAX = WC_CIPHER_AES_CCM 983 }; 984 985 /* PK=public key (asymmetric) based algorithms */ 986 enum wc_PkType { 987 WC_PK_TYPE_NONE = 0, 988 WC_PK_TYPE_RSA = 1, 989 WC_PK_TYPE_DH = 2, 990 WC_PK_TYPE_ECDH = 3, 991 WC_PK_TYPE_ECDSA_SIGN = 4, 992 WC_PK_TYPE_ECDSA_VERIFY = 5, 993 WC_PK_TYPE_ED25519_SIGN = 6, 994 WC_PK_TYPE_CURVE25519 = 7, 995 WC_PK_TYPE_RSA_KEYGEN = 8, 996 WC_PK_TYPE_EC_KEYGEN = 9, 997 WC_PK_TYPE_RSA_CHECK_PRIV_KEY = 10, 998 WC_PK_TYPE_EC_CHECK_PRIV_KEY = 11, 999 WC_PK_TYPE_ED448 = 12, 1000 WC_PK_TYPE_CURVE448 = 13, 1001 WC_PK_TYPE_ED25519_VERIFY = 14, 1002 WC_PK_TYPE_ED25519_KEYGEN = 15, 1003 WC_PK_TYPE_CURVE25519_KEYGEN = 16, 1004 WC_PK_TYPE_MAX = WC_PK_TYPE_CURVE25519_KEYGEN 1005 }; 1006 1007 1008 /* settings detection for compile vs runtime math incompatibilities */ 1009 enum { 1010 #if !defined(USE_FAST_MATH) && !defined(SIZEOF_LONG) && !defined(SIZEOF_LONG_LONG) 1011 CTC_SETTINGS = 0x0 1012 #elif !defined(USE_FAST_MATH) && defined(SIZEOF_LONG) && (SIZEOF_LONG == 8) 1013 CTC_SETTINGS = 0x1 1014 #elif !defined(USE_FAST_MATH) && defined(SIZEOF_LONG_LONG) && (SIZEOF_LONG_LONG == 8) 1015 CTC_SETTINGS = 0x2 1016 #elif !defined(USE_FAST_MATH) && defined(SIZEOF_LONG_LONG) && (SIZEOF_LONG_LONG == 4) 1017 CTC_SETTINGS = 0x4 1018 #elif defined(USE_FAST_MATH) && !defined(SIZEOF_LONG) && !defined(SIZEOF_LONG_LONG) 1019 CTC_SETTINGS = 0x8 1020 #elif defined(USE_FAST_MATH) && defined(SIZEOF_LONG) && (SIZEOF_LONG == 8) 1021 CTC_SETTINGS = 0x10 1022 #elif defined(USE_FAST_MATH) && defined(SIZEOF_LONG_LONG) && (SIZEOF_LONG_LONG == 8) 1023 CTC_SETTINGS = 0x20 1024 #elif defined(USE_FAST_MATH) && defined(SIZEOF_LONG_LONG) && (SIZEOF_LONG_LONG == 4) 1025 CTC_SETTINGS = 0x40 1026 #else 1027 #error "bad math long / long long settings" 1028 #endif 1029 }; 1030 1031 1032 WOLFSSL_API word32 CheckRunTimeSettings(void); 1033 1034 /* If user uses RSA, DH, DSA, or ECC math lib directly then fast math and long 1035 types need to match at compile time and run time, CheckCtcSettings will 1036 return 1 if a match otherwise 0 */ 1037 #define CheckCtcSettings() (CTC_SETTINGS == CheckRunTimeSettings()) 1038 1039 /* invalid device id */ 1040 #define INVALID_DEVID -2 1041 1042 1043 /* AESNI requires alignment and ARMASM gains some performance from it 1044 * Xilinx RSA operations require alignment */ 1045 #if defined(WOLFSSL_AESNI) || defined(WOLFSSL_ARMASM) || \ 1046 defined(USE_INTEL_SPEEDUP) || defined(WOLFSSL_AFALG_XILINX) 1047 #ifndef WOLFSSL_USE_ALIGN 1048 #define WOLFSSL_USE_ALIGN 1049 #endif 1050 #endif /* WOLFSSL_AESNI || WOLFSSL_ARMASM || USE_INTEL_SPEEDUP || WOLFSSL_AFALG_XILINX */ 1051 1052 #ifdef WOLFSSL_USE_ALIGN 1053 #if !defined(ALIGN16) 1054 #if defined(__IAR_SYSTEMS_ICC__) || defined(__GNUC__) 1055 #define ALIGN16 __attribute__ ( (aligned (16))) 1056 #elif defined(_MSC_VER) 1057 /* disable align warning, we want alignment ! */ 1058 #pragma warning(disable: 4324) 1059 #define ALIGN16 __declspec (align (16)) 1060 #else 1061 #define ALIGN16 1062 #endif 1063 #endif /* !ALIGN16 */ 1064 1065 #if !defined (ALIGN32) 1066 #if defined(__IAR_SYSTEMS_ICC__) || defined(__GNUC__) 1067 #define ALIGN32 __attribute__ ( (aligned (32))) 1068 #elif defined(_MSC_VER) 1069 /* disable align warning, we want alignment ! */ 1070 #pragma warning(disable: 4324) 1071 #define ALIGN32 __declspec (align (32)) 1072 #else 1073 #define ALIGN32 1074 #endif 1075 #endif /* !ALIGN32 */ 1076 1077 #if !defined(ALIGN64) 1078 #if defined(__IAR_SYSTEMS_ICC__) || defined(__GNUC__) 1079 #define ALIGN64 __attribute__ ( (aligned (64))) 1080 #elif defined(_MSC_VER) 1081 /* disable align warning, we want alignment ! */ 1082 #pragma warning(disable: 4324) 1083 #define ALIGN64 __declspec (align (64)) 1084 #else 1085 #define ALIGN64 1086 #endif 1087 #endif /* !ALIGN64 */ 1088 1089 #if defined(__IAR_SYSTEMS_ICC__) || defined(__GNUC__) 1090 #define ALIGN128 __attribute__ ( (aligned (128))) 1091 #elif defined(_MSC_VER) 1092 /* disable align warning, we want alignment ! */ 1093 #pragma warning(disable: 4324) 1094 #define ALIGN128 __declspec (align (128)) 1095 #else 1096 #define ALIGN128 1097 #endif 1098 1099 #if defined(__IAR_SYSTEMS_ICC__) || defined(__GNUC__) 1100 #define ALIGN256 __attribute__ ( (aligned (256))) 1101 #elif defined(_MSC_VER) 1102 /* disable align warning, we want alignment ! */ 1103 #pragma warning(disable: 4324) 1104 #define ALIGN256 __declspec (align (256)) 1105 #else 1106 #define ALIGN256 1107 #endif 1108 1109 #else 1110 #ifndef ALIGN16 1111 #define ALIGN16 1112 #endif 1113 #ifndef ALIGN32 1114 #define ALIGN32 1115 #endif 1116 #ifndef ALIGN64 1117 #define ALIGN64 1118 #endif 1119 #ifndef ALIGN128 1120 #define ALIGN128 1121 #endif 1122 #ifndef ALIGN256 1123 #define ALIGN256 1124 #endif 1125 #endif /* WOLFSSL_USE_ALIGN */ 1126 1127 #if !defined(PEDANTIC_EXTENSION) 1128 #if defined(__GNUC__) 1129 #define PEDANTIC_EXTENSION __extension__ 1130 #else 1131 #define PEDANTIC_EXTENSION 1132 #endif 1133 #endif /* !PEDANTIC_EXTENSION */ 1134 1135 1136 #ifndef TRUE 1137 #define TRUE 1 1138 #endif 1139 #ifndef FALSE 1140 #define FALSE 0 1141 #endif 1142 1143 1144 #if defined(HAVE_STACK_SIZE) 1145 #define EXIT_TEST(ret) return (THREAD_RETURN)((size_t)(ret)) 1146 #else 1147 #define EXIT_TEST(ret) return ret 1148 #endif 1149 1150 1151 #if (defined(__IAR_SYSTEMS_ICC__) && (__IAR_SYSTEMS_ICC__ > 8)) || \ 1152 defined(__GNUC__) 1153 #define WOLFSSL_PACK __attribute__ ((packed)) 1154 #else 1155 #define WOLFSSL_PACK 1156 #endif 1157 1158 #ifndef __GNUC_PREREQ 1159 #if defined(__GNUC__) && defined(__GNUC_MINOR__) 1160 #define __GNUC_PREREQ(maj, min) \ 1161 ((__GNUC__ << 16) + __GNUC_MINOR__ >= ((maj) << 16) + (min)) 1162 #else 1163 #define __GNUC_PREREQ(maj, min) (0) /* not GNUC */ 1164 #endif 1165 #endif 1166 1167 #if defined(__IAR_SYSTEMS_ICC__) || defined(__GNUC__) 1168 #define WC_NORETURN __attribute__((noreturn)) 1169 #else 1170 #define WC_NORETURN 1171 #endif 1172 1173 #if defined(WOLFSSL_KEY_GEN) || defined(HAVE_COMP_KEY) || \ 1174 defined(WOLFSSL_DEBUG_MATH) || defined(DEBUG_WOLFSSL) || \ 1175 defined(WOLFSSL_PUBLIC_MP) || defined(OPENSSL_EXTRA) || \ 1176 (defined(HAVE_ECC) && defined(HAVE_ECC_KEY_EXPORT)) 1177 #undef WC_MP_TO_RADIX 1178 #define WC_MP_TO_RADIX 1179 #endif 1180 1181 #if defined(__GNUC__) && __GNUC__ > 5 1182 #define PRAGMA_GCC_DIAG_PUSH _Pragma("GCC diagnostic push") 1183 #define PRAGMA_GCC(str) _Pragma(str) 1184 #define PRAGMA_GCC_DIAG_POP _Pragma("GCC diagnostic pop") 1185 #else 1186 #define PRAGMA_GCC_DIAG_PUSH 1187 #define PRAGMA_GCC(str) 1188 #define PRAGMA_GCC_DIAG_POP 1189 #endif 1190 1191 #ifdef __clang__ 1192 #define PRAGMA_CLANG_DIAG_PUSH _Pragma("clang diagnostic push") 1193 #define PRAGMA_CLANG(str) _Pragma(str) 1194 #define PRAGMA_CLANG_DIAG_POP _Pragma("clang diagnostic pop") 1195 #else 1196 #define PRAGMA_CLANG_DIAG_PUSH 1197 #define PRAGMA_CLANG(str) 1198 #define PRAGMA_CLANG_DIAG_POP 1199 #endif 1200 1201 #ifdef DEBUG_VECTOR_REGISTER_ACCESS 1202 WOLFSSL_API extern THREAD_LS_T int wc_svr_count; 1203 WOLFSSL_API extern THREAD_LS_T const char *wc_svr_last_file; 1204 WOLFSSL_API extern THREAD_LS_T int wc_svr_last_line; 1205 1206 #ifdef DEBUG_VECTOR_REGISTERS_ABORT_ON_FAIL 1207 #define DEBUG_VECTOR_REGISTERS_EXTRA_FAIL_CLAUSE abort(); 1208 #elif defined(DEBUG_VECTOR_REGISTERS_EXIT_ON_FAIL) 1209 #define DEBUG_VECTOR_REGISTERS_EXTRA_FAIL_CLAUSE exit(1); 1210 #else 1211 #define DEBUG_VECTOR_REGISTERS_EXTRA_FAIL_CLAUSE 1212 #endif 1213 1214 #define SAVE_VECTOR_REGISTERS(...) { \ 1215 ++wc_svr_count; \ 1216 if (wc_svr_count > 5) { \ 1217 fprintf(stderr, \ 1218 "%s @ L%d : incr : wc_svr_count %d (last op %s L%d)\n", \ 1219 __FILE__, \ 1220 __LINE__, \ 1221 wc_svr_count, \ 1222 wc_svr_last_file, \ 1223 wc_svr_last_line); \ 1224 DEBUG_VECTOR_REGISTERS_EXTRA_FAIL_CLAUSE \ 1225 } \ 1226 wc_svr_last_file = __FILE__; \ 1227 wc_svr_last_line = __LINE__; \ 1228 } 1229 #define ASSERT_SAVED_VECTOR_REGISTERS(fail_clause) { \ 1230 if (wc_svr_count <= 0) { \ 1231 fprintf(stderr, \ 1232 "ASSERT_SAVED_VECTOR_REGISTERS : %s @ L%d : wc_svr_count %d (last op %s L%d)\n", \ 1233 __FILE__, \ 1234 __LINE__, \ 1235 wc_svr_count, \ 1236 wc_svr_last_file, \ 1237 wc_svr_last_line); \ 1238 DEBUG_VECTOR_REGISTERS_EXTRA_FAIL_CLAUSE \ 1239 { fail_clause } \ 1240 } \ 1241 } 1242 #define ASSERT_RESTORED_VECTOR_REGISTERS(fail_clause) { \ 1243 if (wc_svr_count != 0) { \ 1244 fprintf(stderr, \ 1245 "ASSERT_RESTORED_VECTOR_REGISTERS : %s @ L%d : wc_svr_count %d (last op %s L%d)\n", \ 1246 __FILE__, \ 1247 __LINE__, \ 1248 wc_svr_count, \ 1249 wc_svr_last_file, \ 1250 wc_svr_last_line); \ 1251 DEBUG_VECTOR_REGISTERS_EXTRA_FAIL_CLAUSE \ 1252 { fail_clause } \ 1253 } \ 1254 } 1255 #define RESTORE_VECTOR_REGISTERS(...) { \ 1256 --wc_svr_count; \ 1257 if ((wc_svr_count > 4) || (wc_svr_count < 0)) { \ 1258 fprintf(stderr, \ 1259 "%s @ L%d : decr : wc_svr_count %d (last op %s L%d)\n", \ 1260 __FILE__, \ 1261 __LINE__, \ 1262 wc_svr_count, \ 1263 wc_svr_last_file, \ 1264 wc_svr_last_line); \ 1265 DEBUG_VECTOR_REGISTERS_EXTRA_FAIL_CLAUSE \ 1266 } \ 1267 wc_svr_last_file = __FILE__; \ 1268 wc_svr_last_line = __LINE__; \ 1269 } 1270 #else 1271 #ifdef _MSC_VER 1272 /* disable buggy MSC warning around while(0), 1273 *"warning C4127: conditional expression is constant" 1274 */ 1275 #pragma warning(disable: 4127) 1276 #endif 1277 #ifndef SAVE_VECTOR_REGISTERS 1278 #define SAVE_VECTOR_REGISTERS(...) do{}while(0) 1279 #endif 1280 #ifndef ASSERT_SAVED_VECTOR_REGISTERS 1281 #define ASSERT_SAVED_VECTOR_REGISTERS(...) do{}while(0) 1282 #endif 1283 #ifndef ASSERT_RESTORED_VECTOR_REGISTERS 1284 #define ASSERT_RESTORED_VECTOR_REGISTERS(...) do{}while(0) 1285 #endif 1286 #ifndef RESTORE_VECTOR_REGISTERS 1287 #define RESTORE_VECTOR_REGISTERS() do{}while(0) 1288 #endif 1289 #endif 1290 1291 1292 #if FIPS_VERSION_GE(5,1) 1293 #define WC_SPKRE_F(x,y) wolfCrypt_SetPrivateKeyReadEnable_fips((x),(y)) 1294 #define PRIVATE_KEY_LOCK() WC_SPKRE_F(0,WC_KEYTYPE_ALL) 1295 #define PRIVATE_KEY_UNLOCK() WC_SPKRE_F(1,WC_KEYTYPE_ALL) 1296 #else 1297 #define PRIVATE_KEY_LOCK() do{}while(0) 1298 #define PRIVATE_KEY_UNLOCK() do{}while(0) 1299 #endif 1300 1301 1302 #ifdef __cplusplus 1303 } /* extern "C" */ 1304 #endif 1305 1306 #endif /* WOLF_CRYPT_TYPES_H */ 1307