luna - wolfssl/wolfcrypt/src/misc.c

   1/* misc.c
   2 *
   3 * Copyright (C) 2006-2026 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
  23DESCRIPTION
  24This module implements the arithmetic-shift right, left, byte swapping, XOR,
  25masking and clearing memory logic.
  26
  27*/
  28
  29#ifdef WOLFSSL_VIS_FOR_TESTS
  30    #ifdef HAVE_CONFIG_H
  31        #include <config.h>
  32    #endif
  33    #include <wolfssl/wolfcrypt/settings.h>
  34#else
  35    #include <wolfssl/wolfcrypt/libwolfssl_sources.h>
  36#endif
  37
  38#ifndef WOLF_CRYPT_MISC_C
  39#define WOLF_CRYPT_MISC_C
  40
  41#include <wolfssl/wolfcrypt/misc.h>
  42
  43/* inlining these functions is a huge speed increase and a small size decrease,
  44   because the functions are smaller than function call setup/cleanup, e.g.,
  45   md5 benchmark is twice as fast with inline.  If you don't want it, then
  46   define NO_INLINE and compile this file into wolfssl, otherwise it's used as
  47   a source header
  48 */
  49
  50/* Check for if compiling misc.c when not needed. */
  51#if !defined(WOLFSSL_MISC_INCLUDED) && !defined(NO_INLINE)
  52    #ifndef WOLFSSL_IGNORE_FILE_WARN
  53        #warning misc.c does not need to be compiled when using inline (NO_INLINE not defined)
  54    #endif
  55
  56#else
  57
  58
  59#if defined(__ICCARM__)
  60    #include <intrinsics.h>
  61#endif
  62
  63
  64#ifdef INTEL_INTRINSICS
  65
  66    #include <stdlib.h>      /* get intrinsic definitions */
  67
  68    /* for non visual studio probably need no long version, 32 bit only
  69     * i.e., _rotl and _rotr */
  70    #pragma intrinsic(_lrotl, _lrotr)
  71
  72    WC_MISC_STATIC WC_INLINE word32 rotlFixed(word32 x, word32 y)
  73    {
  74        return y ? _lrotl(x, y) : x;
  75    }
  76
  77    WC_MISC_STATIC WC_INLINE word32 rotrFixed(word32 x, word32 y)
  78    {
  79        return y ? _lrotr(x, y) : x;
  80    }
  81
  82#elif defined(__CCRX__)
  83
  84    #include <builtin.h>      /* get intrinsic definitions */
  85
  86    #if !defined(NO_INLINE)
  87
  88    #define rotlFixed(x, y) _builtin_rotl(x, y)
  89
  90    #define rotrFixed(x, y) _builtin_rotr(x, y)
  91
  92    #else /* create real function */
  93
  94    WC_MISC_STATIC WC_INLINE word32 rotlFixed(word32 x, word32 y)
  95    {
  96        return _builtin_rotl(x, y);
  97    }
  98
  99    WC_MISC_STATIC WC_INLINE word32 rotrFixed(word32 x, word32 y)
 100    {
 101        return _builtin_rotr(x, y);
 102    }
 103
 104    #endif
 105
 106#else /* generic */
 107/* This routine performs a left circular arithmetic shift of <x> by <y> value. */
 108
 109    WC_MISC_STATIC WC_INLINE word32 rotlFixed(word32 x, word32 y)
 110    {
 111        return (x << y) | (x >> (sizeof(x) * 8 - y));
 112    }
 113
 114/* This routine performs a right circular arithmetic shift of <x> by <y> value. */
 115    WC_MISC_STATIC WC_INLINE word32 rotrFixed(word32 x, word32 y)
 116    {
 117        return (x >> y) | (x << (sizeof(x) * 8 - y));
 118    }
 119
 120#endif
 121
 122/* This routine performs a left circular arithmetic shift of <x> by <y> value */
 123WC_MISC_STATIC WC_INLINE word16 rotlFixed16(word16 x, word16 y)
 124{
 125    return (word16)((x << y) | (x >> (sizeof(x) * 8U - y)));
 126}
 127
 128
 129/* This routine performs a right circular arithmetic shift of <x> by <y> value */
 130WC_MISC_STATIC WC_INLINE word16 rotrFixed16(word16 x, word16 y)
 131{
 132    return (word16)((x >> y) | (x << (sizeof(x) * 8U - y)));
 133}
 134
 135/* This routine performs a byte swap of 32-bit word value. */
 136#if defined(__CCRX__) && !defined(NO_INLINE) /* shortest version for CC-RX */
 137    #define ByteReverseWord32(value) _builtin_revl(value)
 138#else
 139WC_MISC_STATIC WC_INLINE word32 ByteReverseWord32(word32 value)
 140{
 141#ifdef PPC_INTRINSICS
 142    /* PPC: load reverse indexed instruction */
 143    return (word32)__lwbrx(&value,0);
 144#elif defined(__ICCARM__)
 145    return (word32)__REV(value);
 146#elif defined(KEIL_INTRINSICS)
 147    return (word32)__rev(value);
 148#elif defined(__CCRX__)
 149    return (word32)_builtin_revl(value);
 150#elif defined(WOLF_ALLOW_BUILTIN) && \
 151        defined(__GNUC_PREREQ) && __GNUC_PREREQ(4, 3)
 152    return (word32)__builtin_bswap32(value);
 153#elif defined(WOLFSSL_BYTESWAP32_ASM) && defined(__GNUC__) && \
 154      defined(__aarch64__)
 155    __asm__ volatile (
 156        "REV32 %0, %0  \n"
 157        : "+r" (value)
 158        :
 159    );
 160    return value;
 161#elif defined(WOLFSSL_BYTESWAP32_ASM) && defined(__GNUC__) && \
 162      (defined(__thumb__) || defined(__arm__))
 163    __asm__ volatile (
 164        "REV %0, %0  \n"
 165        : "+r" (value)
 166        :
 167    );
 168    return value;
 169#elif defined(FAST_ROTATE)
 170    /* 5 instructions with rotate instruction, 9 without */
 171    return (rotrFixed(value, 8U) & 0xff00ff00) |
 172           (rotlFixed(value, 8U) & 0x00ff00ff);
 173#else
 174    /* 6 instructions with rotate instruction, 8 without */
 175    value = ((value & 0xFF00FF00) >> 8) | ((value & 0x00FF00FF) << 8);
 176    return rotlFixed(value, 16U);
 177#endif
 178}
 179#endif /* __CCRX__ */
 180/* This routine performs a byte swap of words array of a given count. */
 181WC_MISC_STATIC WC_INLINE void ByteReverseWords(word32* out, const word32* in,
 182                                    word32 byteCount)
 183{
 184    word32 i;
 185
 186#ifdef WOLFSSL_USE_ALIGN
 187    if ((((size_t)in & 0x3) == 0) &&
 188        (((size_t)out & 0x3) == 0))
 189#endif
 190    {
 191        word32 count = byteCount/(word32)sizeof(word32);
 192        for (i = 0; i < count; i++)
 193            out[i] = ByteReverseWord32(in[i]);
 194    }
 195#ifdef WOLFSSL_USE_ALIGN
 196    else if (((size_t)in & 0x3) == 0) {
 197        byte *out_bytes = (byte *)out;
 198        word32 scratch;
 199
 200        byteCount &= ~0x3U;
 201
 202        for (i = 0; i < byteCount; i += (word32)sizeof(word32)) {
 203            scratch = ByteReverseWord32(*in++);
 204            XMEMCPY(out_bytes + i, &scratch, sizeof(scratch));
 205        }
 206    }
 207    else if (((size_t)out & 0x3) == 0) {
 208        const byte *in_bytes = (const byte *)in;
 209        word32 scratch;
 210
 211        byteCount &= ~0x3U;
 212
 213        for (i = 0; i < byteCount; i += (word32)sizeof(word32)) {
 214            XMEMCPY(&scratch, in_bytes + i, sizeof(scratch));
 215            *out++ = ByteReverseWord32(scratch);
 216        }
 217    }
 218    else {
 219        const byte *in_bytes = (const byte *)in;
 220        byte *out_bytes = (byte *)out;
 221        word32 scratch;
 222
 223        byteCount &= ~0x3U;
 224
 225        for (i = 0; i < byteCount; i += (word32)sizeof(word32)) {
 226            XMEMCPY(&scratch, in_bytes + i, sizeof(scratch));
 227            scratch = ByteReverseWord32(scratch);
 228            XMEMCPY(out_bytes + i, &scratch, sizeof(scratch));
 229        }
 230    }
 231#endif
 232}
 233
 234WC_MISC_STATIC WC_INLINE word32 readUnalignedWord32(const byte *in)
 235{
 236    if (((wc_ptr_t)in & (wc_ptr_t)(sizeof(word32) - 1U)) == (wc_ptr_t)0)
 237        return *(const word32 *)in;
 238    else {
 239        word32 out = 0; /* else CONFIG_FORTIFY_SOURCE -Wmaybe-uninitialized */
 240        XMEMCPY(&out, in, sizeof(out));
 241        return out;
 242    }
 243}
 244
 245WC_MISC_STATIC WC_INLINE word32 writeUnalignedWord32(void *out, word32 in)
 246{
 247    if (((wc_ptr_t)out & (wc_ptr_t)(sizeof(word32) - 1U)) == (wc_ptr_t)0)
 248        *(word32 *)out = in;
 249    else {
 250        XMEMCPY(out, &in, sizeof(in));
 251    }
 252    return in;
 253}
 254
 255WC_MISC_STATIC WC_INLINE void readUnalignedWords32(word32 *out, const byte *in,
 256                                                   size_t count)
 257{
 258    if (((wc_ptr_t)in & (wc_ptr_t)(sizeof(word32) - 1U)) == (wc_ptr_t)0) {
 259        const word32 *in_word32 = (const word32 *)in;
 260        while (count-- > 0)
 261            *out++ = *in_word32++;
 262    }
 263    else {
 264        XMEMCPY(out, in, count * sizeof(*out));
 265    }
 266}
 267
 268WC_MISC_STATIC WC_INLINE void writeUnalignedWords32(byte *out, const word32 *in,
 269                                                    size_t count)
 270{
 271    if (((wc_ptr_t)out & (wc_ptr_t)(sizeof(word32) - 1U)) == (wc_ptr_t)0) {
 272        word32 *out_word32 = (word32 *)out;
 273        while (count-- > 0)
 274            *out_word32++ = *in++;
 275    }
 276    else {
 277        XMEMCPY(out, in, count * sizeof(*in));
 278    }
 279}
 280
 281#if defined(WORD64_AVAILABLE) && !defined(WOLFSSL_NO_WORD64_OPS)
 282
 283WC_MISC_STATIC WC_INLINE word64 readUnalignedWord64(const byte *in)
 284{
 285    if (((wc_ptr_t)in & (wc_ptr_t)(sizeof(word64) - 1U)) == (wc_ptr_t)0)
 286        return *(const word64 *)in;
 287    else {
 288        word64 out = 0; /* else CONFIG_FORTIFY_SOURCE -Wmaybe-uninitialized */
 289        XMEMCPY(&out, in, sizeof(out));
 290        return out;
 291    }
 292}
 293
 294WC_MISC_STATIC WC_INLINE word64 writeUnalignedWord64(void *out, word64 in)
 295{
 296    if (((wc_ptr_t)out & (wc_ptr_t)(sizeof(word64) - 1U)) == (wc_ptr_t)0)
 297        *(word64 *)out = in;
 298    else {
 299        XMEMCPY(out, &in, sizeof(in));
 300    }
 301    return in;
 302}
 303
 304WC_MISC_STATIC WC_INLINE void readUnalignedWords64(word64 *out, const byte *in,
 305                                                   size_t count)
 306{
 307    if (((wc_ptr_t)in & (wc_ptr_t)(sizeof(word64) - 1U)) == (wc_ptr_t)0) {
 308        const word64 *in_word64 = (const word64 *)in;
 309        while (count-- > 0)
 310            *out++ = *in_word64++;
 311    }
 312    else {
 313        XMEMCPY(out, in, count * sizeof(*out));
 314    }
 315}
 316
 317WC_MISC_STATIC WC_INLINE void writeUnalignedWords64(byte *out, const word64 *in,
 318                                                    size_t count)
 319{
 320    if (((wc_ptr_t)out & (wc_ptr_t)(sizeof(word64) - 1U)) == (wc_ptr_t)0) {
 321        word64 *out_word64 = (word64 *)out;
 322        while (count-- > 0)
 323            *out_word64++ = *in++;
 324    }
 325    else {
 326        XMEMCPY(out, in, count * sizeof(*in));
 327    }
 328}
 329
 330WC_MISC_STATIC WC_INLINE word64 rotlFixed64(word64 x, word64 y)
 331{
 332    return (x << y) | (x >> (sizeof(y) * 8 - y));
 333}
 334
 335
 336WC_MISC_STATIC WC_INLINE word64 rotrFixed64(word64 x, word64 y)
 337{
 338    return (x >> y) | (x << (sizeof(y) * 8 - y));
 339}
 340
 341
 342WC_MISC_STATIC WC_INLINE word64 ByteReverseWord64(word64 value)
 343{
 344#if defined(WOLF_ALLOW_BUILTIN) && defined(__GNUC_PREREQ) && __GNUC_PREREQ(4, 3)
 345    return (word64)__builtin_bswap64(value);
 346#elif defined(WOLFCRYPT_SLOW_WORD64)
 347    return (word64)((word64)ByteReverseWord32((word32) value)) << 32 |
 348        (word64)ByteReverseWord32((word32)(value   >> 32));
 349#else
 350    value = ((value & W64LIT(0xFF00FF00FF00FF00)) >> 8) |
 351        ((value & W64LIT(0x00FF00FF00FF00FF)) << 8);
 352    value = ((value & W64LIT(0xFFFF0000FFFF0000)) >> 16) |
 353        ((value & W64LIT(0x0000FFFF0000FFFF)) << 16);
 354    return rotlFixed64(value, 32U);
 355#endif
 356}
 357
 358
 359WC_MISC_STATIC WC_INLINE void ByteReverseWords64(word64* out, const word64* in,
 360                                      word32 byteCount)
 361{
 362    word32 count = byteCount/(word32)sizeof(word64), i;
 363
 364#ifdef WOLFSSL_USE_ALIGN
 365    if ((((size_t)in & 0x7) == 0) &&
 366        (((size_t)out & 0x7) == 0))
 367#endif
 368    {
 369        for (i = 0; i < count; i++)
 370            out[i] = ByteReverseWord64(in[i]);
 371    }
 372#ifdef WOLFSSL_USE_ALIGN
 373    else if (((size_t)in & 0x7) == 0) {
 374        byte *out_bytes = (byte *)out;
 375        word64 scratch;
 376
 377        byteCount &= ~0x7U;
 378
 379        for (i = 0; i < byteCount; i += (word32)sizeof(word64)) {
 380            scratch = ByteReverseWord64(*in++);
 381            XMEMCPY(out_bytes + i, &scratch, sizeof(scratch));
 382        }
 383    }
 384    else if (((size_t)out & 0x7) == 0) {
 385        const byte *in_bytes = (const byte *)in;
 386        word64 scratch;
 387
 388        byteCount &= ~0x7U;
 389
 390        for (i = 0; i < byteCount; i += (word32)sizeof(word64)) {
 391            XMEMCPY(&scratch, in_bytes + i, sizeof(scratch));
 392            *out++ = ByteReverseWord64(scratch);
 393        }
 394    }
 395    else {
 396        const byte *in_bytes = (const byte *)in;
 397        byte *out_bytes = (byte *)out;
 398        word64 scratch;
 399
 400        byteCount &= ~0x7U;
 401
 402        for (i = 0; i < byteCount; i += (word32)sizeof(word64)) {
 403            XMEMCPY(&scratch, in_bytes + i, sizeof(scratch));
 404            scratch = ByteReverseWord64(scratch);
 405            XMEMCPY(out_bytes + i, &scratch, sizeof(scratch));
 406        }
 407    }
 408#endif
 409}
 410
 411#endif /* WORD64_AVAILABLE && !WOLFSSL_NO_WORD64_OPS */
 412
 413#ifndef WOLFSSL_NO_XOR_OPS
 414
 415/* Leave no doubt that WOLFSSL_WORD_SIZE is a power of 2. */
 416wc_static_assert((WOLFSSL_WORD_SIZE & (WOLFSSL_WORD_SIZE - 1)) == 0);
 417
 418/* This routine performs a bitwise XOR operation of <*a> and <*b> for <n> number
 419of wolfssl_words, placing the result in <*r>. */
 420WC_MISC_STATIC WC_INLINE void XorWordsOut(wolfssl_word** r,
 421                       const wolfssl_word** a, const wolfssl_word** b, word32 n)
 422{
 423    const wolfssl_word *e = *a + n;
 424
 425    while (*a < e)
 426        *((*r)++) = *((*a)++) ^ *((*b)++);
 427}
 428
 429/* This routine performs a bitwise XOR operation of <*buf> and <*mask> of n
 430counts, placing the result in <*out>. */
 431
 432WC_MISC_STATIC WC_INLINE void xorbufout(void* out, const void* buf,
 433                                        const void* mask, word32 count)
 434{
 435    byte*       o = (byte*)out;
 436    const byte* b = (const byte*)buf;
 437    const byte* m = (const byte*)mask;
 438
 439    /* type-punning helpers */
 440    union {
 441        byte* bp;
 442        wolfssl_word* wp;
 443    } tpo;
 444    union {
 445        const byte* bp;
 446        const wolfssl_word* wp;
 447    } tpb, tpm;
 448
 449    if (((((wc_ptr_t)o) & (WOLFSSL_WORD_SIZE - 1)) == 0) &&
 450        ((((wc_ptr_t)b) & (WOLFSSL_WORD_SIZE - 1)) == 0) &&
 451        ((((wc_ptr_t)m) & (WOLFSSL_WORD_SIZE - 1)) == 0))
 452    {
 453        /* All buffers are already aligned.  Possible to XOR by words without
 454         * fixup.
 455         */
 456
 457        tpo.bp = o;
 458        tpb.bp = b;
 459        tpm.bp = m;
 460        XorWordsOut(&tpo.wp, &tpb.wp, &tpm.wp, count >> WOLFSSL_WORD_SIZE_LOG2);
 461        o = tpo.bp;
 462        b = tpb.bp;
 463        m = tpm.bp;
 464        count &= (WOLFSSL_WORD_SIZE - 1);
 465    }
 466    else if ((((wc_ptr_t)o) & (WOLFSSL_WORD_SIZE - 1)) ==
 467             (((wc_ptr_t)b) & (WOLFSSL_WORD_SIZE - 1)) &&
 468             (((wc_ptr_t)b) & (WOLFSSL_WORD_SIZE - 1)) ==
 469             (((wc_ptr_t)m) & (WOLFSSL_WORD_SIZE - 1)))
 470    {
 471        /* Alignment can be fixed up to allow XOR by words. */
 472
 473        /* Perform bytewise xor until pointers are aligned to
 474         * WOLFSSL_WORD_SIZE.
 475         */
 476        while ((((wc_ptr_t)b & (WOLFSSL_WORD_SIZE - 1)) != 0) && (count > 0))
 477        {
 478            *o++ = (byte)(*b++ ^ *m++);
 479            count--;
 480        }
 481
 482        tpo.bp = o;
 483        tpb.bp = b;
 484        tpm.bp = m;
 485        XorWordsOut(&tpo.wp, &tpb.wp, &tpm.wp, count >> WOLFSSL_WORD_SIZE_LOG2);
 486        o = tpo.bp;
 487        b = tpb.bp;
 488        m = tpm.bp;
 489        count &= (WOLFSSL_WORD_SIZE - 1);
 490    }
 491
 492    while (count > 0) {
 493        *o++ = (byte)(*b++ ^ *m++);
 494        count--;
 495    }
 496
 497}
 498
 499/* This routine performs a bitwise XOR operation of <*r> and <*a> for <n> number
 500of wolfssl_words, placing the result in <*r>. */
 501WC_MISC_STATIC WC_INLINE void XorWords(wolfssl_word** r, const wolfssl_word** a,
 502                                       word32 n)
 503{
 504    const wolfssl_word *e = *a + n;
 505
 506    while (*a < e)
 507        *((*r)++) ^= *((*a)++);
 508}
 509
 510/* This routine performs a bitwise XOR operation of <*buf> and <*mask> of n
 511counts, placing the result in <*buf>. */
 512
 513WC_MISC_STATIC WC_INLINE void xorbuf(void* buf, const void* mask, word32 count)
 514{
 515    byte*       b = (byte*)buf;
 516    const byte* m = (const byte*)mask;
 517
 518    /* type-punning helpers */
 519    union {
 520        byte* bp;
 521        wolfssl_word* wp;
 522    } tpb;
 523    union {
 524        const byte* bp;
 525        const wolfssl_word* wp;
 526    } tpm;
 527
 528    if ((((wc_ptr_t)buf & (WOLFSSL_WORD_SIZE - 1)) == 0) &&
 529        (((wc_ptr_t)mask & (WOLFSSL_WORD_SIZE - 1)) == 0))
 530    {
 531        /* Both buffers are already aligned.  Possible to XOR by words without
 532         * fixup.
 533         */
 534
 535        tpb.bp = b;
 536        tpm.bp = m;
 537        /* Work around false positives from linuxkm CONFIG_FORTIFY_SOURCE. */
 538        #if defined(WOLFSSL_LINUXKM) && defined(CONFIG_FORTIFY_SOURCE)
 539            PRAGMA_GCC_DIAG_PUSH;
 540            PRAGMA_GCC("GCC diagnostic ignored \"-Wmaybe-uninitialized\"")
 541        #endif
 542        XorWords(&tpb.wp, &tpm.wp, count >> WOLFSSL_WORD_SIZE_LOG2);
 543        #if defined(WOLFSSL_LINUXKM) && defined(CONFIG_FORTIFY_SOURCE)
 544            PRAGMA_GCC_DIAG_POP;
 545        #endif
 546        b = tpb.bp;
 547        m = tpm.bp;
 548        count &= (WOLFSSL_WORD_SIZE - 1);
 549    }
 550    else if (((wc_ptr_t)buf & (WOLFSSL_WORD_SIZE - 1)) ==
 551             ((wc_ptr_t)mask & (WOLFSSL_WORD_SIZE - 1)))
 552    {
 553        /* Alignment can be fixed up to allow XOR by words. */
 554
 555        /* Perform bytewise xor until pointers are aligned to
 556         * WOLFSSL_WORD_SIZE.
 557         */
 558        while ((((wc_ptr_t)b & (WOLFSSL_WORD_SIZE - 1)) != 0) && (count > 0))
 559        {
 560            *(b++) ^= *(m++);
 561            count--;
 562        }
 563
 564        tpb.bp = b;
 565        tpm.bp = m;
 566        /* Work around false positives from linuxkm CONFIG_FORTIFY_SOURCE. */
 567        #if defined(WOLFSSL_LINUXKM) && defined(CONFIG_FORTIFY_SOURCE)
 568            PRAGMA_GCC_DIAG_PUSH;
 569            PRAGMA_GCC("GCC diagnostic ignored \"-Wmaybe-uninitialized\"")
 570        #endif
 571        XorWords(&tpb.wp, &tpm.wp, count >> WOLFSSL_WORD_SIZE_LOG2);
 572        #if defined(WOLFSSL_LINUXKM) && defined(CONFIG_FORTIFY_SOURCE)
 573            PRAGMA_GCC_DIAG_POP;
 574        #endif
 575        b = tpb.bp;
 576        m = tpm.bp;
 577        count &= (WOLFSSL_WORD_SIZE - 1);
 578    }
 579
 580    while (count > 0) {
 581        *b++ ^= *m++;
 582        count--;
 583    }
 584}
 585
 586#endif /* !WOLFSSL_NO_XOR_OPS */
 587
 588#ifndef WOLFSSL_NO_FORCE_ZERO
 589/* This routine fills the first len bytes of the memory area pointed by mem
 590   with zeros. It ensures compiler optimization doesn't skip it. */
 591WC_MISC_STATIC WC_INLINE void ForceZero(void* mem, size_t len)
 592{
 593    byte *zb = (byte *)mem;
 594    unsigned long *zl;
 595
 596    XFENCE();
 597
 598    while ((wc_ptr_t)zb & (wc_ptr_t)(sizeof(unsigned long) - 1U)) {
 599        if (len == 0)
 600            return;
 601        *zb++ = 0;
 602        --len;
 603    }
 604
 605    zl = (unsigned long *)zb;
 606
 607    while (len >= sizeof(unsigned long)) {
 608        *zl++ = 0;
 609        len -= sizeof(unsigned long);
 610    }
 611
 612    zb = (byte *)zl;
 613
 614    while (len) {
 615        *zb++ = 0;
 616        --len;
 617    }
 618
 619    XFENCE();
 620}
 621#endif
 622
 623
 624#ifndef WOLFSSL_NO_CONST_CMP
 625/* check all length bytes for equality, return 0 on success */
 626WC_MISC_STATIC WC_INLINE int ConstantCompare(const byte* a, const byte* b,
 627                                             int length)
 628{
 629    int i;
 630    int compareSum = 0;
 631
 632    for (i = 0; i < length; i++) {
 633        compareSum |= a[i] ^ b[i];
 634    }
 635
 636    return compareSum;
 637}
 638#endif
 639
 640
 641#if defined(WOLFSSL_NO_CT_OPS) && (!defined(NO_RSA) || !defined(WOLFCRYPT_ONLY)) \
 642    && (!defined(WOLFSSL_RSA_VERIFY_ONLY))
 643/* constant time operations with mask are required for RSA and TLS operations */
 644#warning constant time operations required unless using NO_RSA & WOLFCRYPT_ONLY
 645#endif
 646
 647#if !defined(WOLFSSL_NO_CT_OPS) || !defined(NO_RSA) || !defined(WOLFCRYPT_ONLY)
 648/* Constant time - mask set when a > b. */
 649WC_MISC_STATIC WC_INLINE byte ctMaskGT(int a, int b)
 650{
 651    return (byte)((((word32)a - (word32)b - 1) >> 31) - 1);
 652}
 653
 654/* Constant time - mask set when a >= b. */
 655WC_MISC_STATIC WC_INLINE byte ctMaskGTE(int a, int b)
 656{
 657    return (byte)((((word32)a - (word32)b) >> 31) - 1);
 658}
 659
 660/* Constant time - mask set when a >= b. */
 661WC_MISC_STATIC WC_INLINE int ctMaskIntGTE(int a, int b)
 662{
 663    return (int)((((word32)a - (word32)b) >> 31) - 1);
 664}
 665
 666#ifdef WORD64_AVAILABLE
 667/* Constant time - mask set when a >= b. */
 668WC_MISC_STATIC WC_INLINE word32 ctMaskWord32GTE(word32 a, word32 b)
 669{
 670  return (word32)((((word64)a - (word64)b) >> 63) - 1);
 671}
 672#endif
 673
 674/* Constant time - mask set when a < b. */
 675WC_MISC_STATIC WC_INLINE byte ctMaskLT(int a, int b)
 676{
 677    return (byte)((((word32)b - (word32)a - 1) >> 31) - 1);
 678}
 679
 680/* Constant time - mask set when a <= b. */
 681WC_MISC_STATIC WC_INLINE byte ctMaskLTE(int a, int b)
 682{
 683    return (byte)((((word32)b - (word32)a) >> 31) - 1);
 684}
 685
 686/* Constant time - mask set when a == b. */
 687WC_MISC_STATIC WC_INLINE byte ctMaskEq(int a, int b)
 688{
 689    return (byte)((byte)(~ctMaskGT(a, b)) & (byte)(~ctMaskLT(a, b)));
 690}
 691
 692/* Constant time - sets 16 bit integer mask when a > b */
 693WC_MISC_STATIC WC_INLINE word16 ctMask16GT(int a, int b)
 694{
 695    return (word16)((((word32)a - (word32)b - 1) >> 31) - 1);
 696}
 697
 698/* Constant time - sets 16 bit integer mask when a >= b */
 699WC_MISC_STATIC WC_INLINE word16 ctMask16GTE(int a, int b)
 700{
 701    return (word16)((((word32)a - (word32)b) >> 31) - 1);
 702}
 703
 704/* Constant time - sets 16 bit integer mask when a < b. */
 705WC_MISC_STATIC WC_INLINE word16 ctMask16LT(int a, int b)
 706{
 707    return (word16)((((word32)b - (word32)a - 1) >> 31) - 1);
 708}
 709
 710/* Constant time - sets 16 bit integer mask when a <= b. */
 711WC_MISC_STATIC WC_INLINE word16 ctMask16LTE(int a, int b)
 712{
 713    return (word16)((((word32)b - (word32)a) >> 31) - 1);
 714}
 715
 716/* Constant time - sets 16 bit integer mask when a == b. */
 717WC_MISC_STATIC WC_INLINE word16 ctMask16Eq(int a, int b)
 718{
 719    return (word16)((word16)(~ctMask16GT(a, b)) & (word16)(~ctMask16LT(a, b)));
 720}
 721
 722/* Constant time - mask set when a != b. */
 723WC_MISC_STATIC WC_INLINE byte ctMaskNotEq(int a, int b)
 724{
 725    return (byte)((byte)ctMaskGT(a, b) | (byte)ctMaskLT(a, b));
 726}
 727
 728/* Constant time - select a when mask is set and b otherwise. */
 729WC_MISC_STATIC WC_INLINE byte ctMaskSel(byte m, byte a, byte b)
 730{
 731    return (byte)((b & ((byte)~(word32)m)) | (a & m));
 732}
 733
 734/* Constant time - select integer a when mask is set and integer b otherwise. */
 735WC_MISC_STATIC WC_INLINE int ctMaskSelInt(byte m, int a, int b)
 736{
 737    return (b & (~(signed int)(signed char)m)) |
 738           (a & ( (signed int)(signed char)m));
 739}
 740
 741/* Constant time - select word32 a when mask is set and word32 b otherwise. */
 742WC_MISC_STATIC WC_INLINE word32 ctMaskSelWord32(byte m, word32 a, word32 b)
 743{
 744    return (((word32)b & (word32)(~(signed int)(signed char)m)) |
 745            ((word32)a & (word32)( (signed int)(signed char)m)));
 746}
 747
 748/* Constant time - bit set when a <= b. */
 749WC_MISC_STATIC WC_INLINE byte ctSetLTE(int a, int b)
 750{
 751    return (byte)(((word32)a - (word32)b - 1) >> 31);
 752}
 753
 754/* Constant time - conditionally copy size bytes from src to dst if mask is set
 755 */
 756WC_MISC_STATIC WC_INLINE void ctMaskCopy(byte mask, byte* dst, byte* src,
 757    word16 size)
 758{
 759    int i;
 760    for (i = 0; i < size; ++i) {
 761        dst[i] ^= (dst[i] ^ src[i]) & mask;
 762    }
 763}
 764
 765#endif /* !WOLFSSL_NO_CT_OPS */
 766
 767#ifndef WOLFSSL_HAVE_MIN
 768    #define WOLFSSL_HAVE_MIN
 769    #if defined(HAVE_FIPS) && !defined(min) /* so ifdef check passes */
 770        #define min min
 771    #endif
 772    /* returns the smaller of a and b */
 773    WC_MISC_STATIC WC_INLINE word32 min(word32 a, word32 b)
 774    {
 775#if !defined(WOLFSSL_NO_CT_OPS) && !defined(WOLFSSL_NO_CT_MAX_MIN) && \
 776    defined(WORD64_AVAILABLE)
 777        volatile word32 gte_mask = (word32)ctMaskWord32GTE(a, b);
 778        word32 r = (a & ~gte_mask);
 779        r |= (b & gte_mask);
 780        return r;
 781#else /* WOLFSSL_NO_CT_OPS */
 782        return a > b ? b : a;
 783#endif /* WOLFSSL_NO_CT_OPS */
 784    }
 785#endif /* !WOLFSSL_HAVE_MIN */
 786
 787#ifndef WOLFSSL_HAVE_MAX
 788    #define WOLFSSL_HAVE_MAX
 789    #if defined(HAVE_FIPS) && !defined(max) /* so ifdef check passes */
 790        #define max max
 791    #endif
 792    WC_MISC_STATIC WC_INLINE word32 max(word32 a, word32 b)
 793    {
 794#if !defined(WOLFSSL_NO_CT_OPS) && !defined(WOLFSSL_NO_CT_MAX_MIN) && \
 795    defined(WORD64_AVAILABLE)
 796        volatile word32 gte_mask = (word32)ctMaskWord32GTE(a, b);
 797        return (a & gte_mask) | (b & ~gte_mask);
 798#else /* WOLFSSL_NO_CT_OPS */
 799        return a > b ? a : b;
 800#endif /* WOLFSSL_NO_CT_OPS */
 801    }
 802#endif /* !WOLFSSL_HAVE_MAX */
 803
 804#ifndef WOLFSSL_NO_INT_ENCODE
 805/* converts a 32 bit integer to 24 bit */
 806WC_MISC_STATIC WC_INLINE void c32to24(word32 in, word24 out)
 807{
 808    out[0] = (byte)((in >> 16) & 0xff);
 809    out[1] = (byte)((in >>  8) & 0xff);
 810    out[2] =  (byte)(in        & 0xff);
 811}
 812
 813/* convert 16 bit integer to opaque */
 814WC_MISC_STATIC WC_INLINE void c16toa(word16 wc_u16, byte* c)
 815{
 816    c[0] = (byte)((wc_u16 >> 8) & 0xff);
 817    c[1] =  (byte)(wc_u16       & 0xff);
 818}
 819
 820/* convert 32 bit integer to opaque */
 821WC_MISC_STATIC WC_INLINE void c32toa(word32 wc_u32, byte* c)
 822{
 823#ifdef WOLFSSL_USE_ALIGN
 824    c[0] = (byte)((wc_u32 >> 24) & 0xff);
 825    c[1] = (byte)((wc_u32 >> 16) & 0xff);
 826    c[2] = (byte)((wc_u32 >>  8) & 0xff);
 827    c[3] =  (byte)(wc_u32        & 0xff);
 828#elif defined(LITTLE_ENDIAN_ORDER)
 829    *(word32*)c = ByteReverseWord32(wc_u32);
 830#else
 831    *(word32*)c = wc_u32;
 832#endif
 833}
 834#endif
 835
 836#ifndef WOLFSSL_NO_INT_DECODE
 837/* convert a 24 bit integer into a 32 bit one */
 838WC_MISC_STATIC WC_INLINE void c24to32(const word24 wc_u24, word32* wc_u32)
 839{
 840    *wc_u32 = ((word32)wc_u24[0] << 16) |
 841              ((word32)wc_u24[1] << 8) |
 842               (word32)wc_u24[2];
 843}
 844
 845
 846/* convert opaque to 24 bit integer */
 847WC_MISC_STATIC WC_INLINE void ato24(const byte* c, word32* wc_u24)
 848{
 849    *wc_u24 = ((word32)c[0] << 16) | ((word32)c[1] << 8) | c[2];
 850}
 851
 852/* convert opaque to 16 bit integer */
 853WC_MISC_STATIC WC_INLINE void ato16(const byte* c, word16* wc_u16)
 854{
 855    *wc_u16 = (word16) ((c[0] << 8) | (c[1]));
 856}
 857
 858/* convert opaque to 32 bit integer */
 859WC_MISC_STATIC WC_INLINE void ato32(const byte* c, word32* wc_u32)
 860{
 861#ifdef WOLFSSL_USE_ALIGN
 862    *wc_u32 = ((word32)c[0] << 24) |
 863              ((word32)c[1] << 16) |
 864              ((word32)c[2] << 8) |
 865               (word32)c[3];
 866#elif defined(LITTLE_ENDIAN_ORDER)
 867    *wc_u32 = ByteReverseWord32(*(word32*)c);
 868#else
 869    *wc_u32 = *(word32*)c;
 870#endif
 871}
 872
 873/* convert opaque to 32 bit integer. Interpret as little endian. */
 874WC_MISC_STATIC WC_INLINE void ato32le(const byte* c, word32* wc_u32)
 875{
 876    *wc_u32 =  (word32)c[0] |
 877              ((word32)c[1] << 8) |
 878              ((word32)c[2] << 16) |
 879              ((word32)c[3] << 24);
 880}
 881
 882
 883WC_MISC_STATIC WC_INLINE word32 btoi(byte b)
 884{
 885    return (word32)(b - 0x30);
 886}
 887#endif
 888
 889WC_MISC_STATIC WC_INLINE signed char HexCharToByte(char ch)
 890{
 891    signed char ret = (signed char)ch;
 892    if (ret >= '0' && ret <= '9')
 893        ret = (signed char)(ret - '0');
 894    else if (ret >= 'A' && ret <= 'F')
 895        ret = (signed char)(ret - ('A' - 10));
 896    else if (ret >= 'a' && ret <= 'f')
 897        ret = (signed char)(ret - ('a' - 10));
 898    else
 899        ret = -1; /* error case - return code must be signed */
 900    return ret;
 901}
 902
 903WC_MISC_STATIC WC_INLINE char ByteToHex(byte in)
 904{
 905    static ALIGN64 const char kHexChar[] = {
 906        '0', '1', '2', '3', '4', '5', '6', '7',
 907        '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'
 908    };
 909    return (char)(kHexChar[in & 0xF]);
 910}
 911
 912WC_MISC_STATIC WC_INLINE int ByteToHexStr(byte in, char* out)
 913{
 914    if (out == NULL)
 915        return -1;
 916
 917    out[0] = ByteToHex((byte)(in >> 4));
 918    out[1] = ByteToHex((byte)(in & 0xf));
 919    return 0;
 920}
 921
 922WC_MISC_STATIC WC_INLINE int CharIsWhiteSpace(char ch)
 923{
 924#ifndef WOLFSSL_NO_CT_OPS
 925    return (ctMaskEq(ch, ' ') |
 926            ctMaskEq(ch, '\t') |
 927            ctMaskEq(ch, '\n')) & 1;
 928#else /* WOLFSSL_NO_CT_OPS */
 929    switch (ch) {
 930        case ' ':
 931        case '\t':
 932        case '\n':
 933            return 1;
 934        default:
 935            return 0;
 936    }
 937#endif /* WOLFSSL_NO_CT_OPS */
 938}
 939
 940#if defined(WOLFSSL_W64_WRAPPER)
 941#if defined(WORD64_AVAILABLE) && !defined(WOLFSSL_W64_WRAPPER_TEST)
 942WC_MISC_STATIC WC_INLINE void w64Increment(w64wrapper *n) {
 943    n->n++;
 944}
 945
 946WC_MISC_STATIC WC_INLINE void w64Decrement(w64wrapper *n) {
 947    n->n--;
 948}
 949
 950WC_MISC_STATIC WC_INLINE byte w64Equal(w64wrapper a, w64wrapper b) {
 951    return (a.n == b.n);
 952}
 953
 954WC_MISC_STATIC WC_INLINE word32 w64GetLow32(w64wrapper n) {
 955    return (word32)n.n;
 956}
 957
 958WC_MISC_STATIC WC_INLINE word32 w64GetHigh32(w64wrapper n) {
 959    return (word32)(n.n >> 32);
 960}
 961
 962WC_MISC_STATIC WC_INLINE void w64SetLow32(w64wrapper *n, word32 low) {
 963    n->n = (n->n & (~(word64)(0xffffffff))) | low;
 964}
 965
 966WC_MISC_STATIC WC_INLINE w64wrapper w64Add32(w64wrapper a, word32 b, byte *wrap)
 967{
 968    a.n += b;
 969    if (a.n < b && wrap != NULL)
 970        *wrap = 1;
 971
 972    return a;
 973}
 974
 975WC_MISC_STATIC WC_INLINE w64wrapper w64Add(w64wrapper a, w64wrapper b,
 976    byte *wrap)
 977{
 978    a.n += b.n;
 979    if (a.n < b.n && wrap != NULL)
 980        *wrap = 1;
 981
 982    return a;
 983}
 984
 985WC_MISC_STATIC WC_INLINE w64wrapper w64Sub32(w64wrapper a, word32 b, byte *wrap)
 986{
 987    if (a.n < b && wrap != NULL)
 988        *wrap = 1;
 989    a.n = a.n - b;
 990    return a;
 991}
 992
 993WC_MISC_STATIC WC_INLINE byte w64GT(w64wrapper a, w64wrapper b)
 994{
 995    return a.n > b.n;
 996}
 997
 998WC_MISC_STATIC WC_INLINE byte w64IsZero(w64wrapper a)
 999{
1000    return a.n == 0;
1001}
1002
1003WC_MISC_STATIC WC_INLINE void c64toa(const w64wrapper *a, byte *out)
1004{
1005#ifdef BIG_ENDIAN_ORDER
1006    XMEMCPY(out, &a->n, sizeof(a->n));
1007#else
1008    word64 _out;
1009    _out = ByteReverseWord64(a->n);
1010    XMEMCPY(out, &_out, sizeof(_out));
1011#endif /* BIG_ENDIAN_ORDER */
1012}
1013
1014WC_MISC_STATIC WC_INLINE void ato64(const byte *in, w64wrapper *w64)
1015{
1016#ifdef BIG_ENDIAN_ORDER
1017    XMEMCPY(&w64->n, in, sizeof(w64->n));
1018#else
1019    union {
1020        word64 w;
1021        byte b[sizeof(word64)];
1022    } _in;
1023    XMEMCPY(_in.b, in, sizeof(_in));
1024    w64->n = ByteReverseWord64(_in.w);
1025#endif /* BIG_ENDIAN_ORDER */
1026}
1027
1028WC_MISC_STATIC WC_INLINE w64wrapper w64From32(word32 hi, word32 lo)
1029{
1030    w64wrapper ret;
1031    ret.n = ((word64)hi << 32) | lo;
1032    return ret;
1033}
1034
1035WC_MISC_STATIC WC_INLINE byte w64GTE(w64wrapper a, w64wrapper b)
1036{
1037    return a.n >= b.n;
1038}
1039
1040WC_MISC_STATIC WC_INLINE byte w64LT(w64wrapper a, w64wrapper b)
1041{
1042    return a.n < b.n;
1043}
1044
1045WC_MISC_STATIC WC_INLINE w64wrapper w64Sub(w64wrapper a, w64wrapper b)
1046{
1047    a.n -= b.n;
1048    return a;
1049}
1050
1051WC_MISC_STATIC WC_INLINE void w64Zero(w64wrapper *a)
1052{
1053    a->n = 0;
1054}
1055
1056WC_MISC_STATIC WC_INLINE w64wrapper w64ShiftRight(w64wrapper a, int shift)
1057{
1058    a.n >>= shift;
1059    return a;
1060}
1061
1062WC_MISC_STATIC WC_INLINE w64wrapper w64ShiftLeft(w64wrapper a, int shift)
1063{
1064    a.n <<= shift;
1065    return a;
1066}
1067
1068WC_MISC_STATIC WC_INLINE w64wrapper w64Mul(word32 a, word32 b)
1069{
1070    w64wrapper ret;
1071    ret.n = (word64)a * (word64)b;
1072    return ret;
1073}
1074
1075#else
1076
1077WC_MISC_STATIC WC_INLINE void w64Increment(w64wrapper *n)
1078{
1079    n->n[1]++;
1080    if (n->n[1] == 0)
1081        n->n[0]++;
1082}
1083
1084WC_MISC_STATIC WC_INLINE void w64Decrement(w64wrapper *n) {
1085    if (n->n[1] == 0)
1086        n->n[0]--;
1087    n->n[1]--;
1088}
1089
1090WC_MISC_STATIC WC_INLINE byte w64Equal(w64wrapper a, w64wrapper b)
1091{
1092    return (a.n[0] == b.n[0] && a.n[1] == b.n[1]);
1093}
1094
1095WC_MISC_STATIC WC_INLINE word32 w64GetLow32(w64wrapper n) {
1096    return n.n[1];
1097}
1098
1099WC_MISC_STATIC WC_INLINE word32 w64GetHigh32(w64wrapper n) {
1100    return n.n[0];
1101}
1102
1103WC_MISC_STATIC WC_INLINE void w64SetLow32(w64wrapper *n, word32 low)
1104{
1105    n->n[1] = low;
1106}
1107
1108WC_MISC_STATIC WC_INLINE w64wrapper w64Add32(w64wrapper a, word32 b, byte *wrap)
1109{
1110    a.n[1] += b;
1111    if (a.n[1] < b) {
1112        a.n[0]++;
1113        if (wrap != NULL && a.n[0] == 0)
1114                *wrap = 1;
1115    }
1116
1117    return a;
1118}
1119
1120WC_MISC_STATIC WC_INLINE w64wrapper w64Add(w64wrapper a, w64wrapper b,
1121    byte *wrap)
1122{
1123    a.n[1] += b.n[1];
1124    if (a.n[1] < b.n[1]) {
1125        a.n[0]++;
1126        if (wrap != NULL && a.n[0] == 0)
1127                *wrap = 1;
1128    }
1129
1130    a.n[0] += b.n[0];
1131    if (wrap != NULL && a.n[0] < b.n[0]) {
1132        *wrap = 1;
1133    }
1134
1135    return a;
1136}
1137
1138WC_MISC_STATIC WC_INLINE w64wrapper w64Sub32(w64wrapper a, word32 b, byte *wrap)
1139{
1140    byte _underflow = 0;
1141    if (a.n[1] < b)
1142        _underflow = 1;
1143
1144    a.n[1] -= b;
1145    if (_underflow) {
1146        if (a.n[0] == 0 && wrap != NULL)
1147            *wrap = 1;
1148        a.n[0]--;
1149    }
1150
1151    return a;
1152}
1153
1154WC_MISC_STATIC WC_INLINE w64wrapper w64Sub(w64wrapper a, w64wrapper b)
1155{
1156    if (a.n[1] < b.n[1])
1157        a.n[0]--;
1158    a.n[1] -= b.n[1];
1159    a.n[0] -= b.n[0];
1160    return a;
1161}
1162
1163WC_MISC_STATIC WC_INLINE void w64Zero(w64wrapper *a)
1164{
1165    a->n[0] = a->n[1] = 0;
1166}
1167
1168WC_MISC_STATIC WC_INLINE byte w64GT(w64wrapper a, w64wrapper b)
1169{
1170    if (a.n[0] > b.n[0])
1171        return 1;
1172    if (a.n[0] == b.n[0])
1173        return a.n[1] > b.n[1];
1174    return 0;
1175}
1176
1177WC_MISC_STATIC WC_INLINE byte w64GTE(w64wrapper a, w64wrapper b)
1178{
1179    if (a.n[0] > b.n[0])
1180        return 1;
1181    if (a.n[0] == b.n[0])
1182        return a.n[1] >= b.n[1];
1183    return 0;
1184}
1185
1186WC_MISC_STATIC WC_INLINE byte w64IsZero(w64wrapper a)
1187{
1188    return a.n[0] == 0 && a.n[1] == 0;
1189}
1190
1191WC_MISC_STATIC WC_INLINE void c64toa(const w64wrapper *a, byte *out)
1192{
1193#ifdef BIG_ENDIAN_ORDER
1194    word32 *_out = (word32*)(out);
1195    _out[0] = a->n[0];
1196    _out[1] = a->n[1];
1197#else
1198    c32toa(a->n[0], out);
1199    c32toa(a->n[1], out + 4);
1200#endif /* BIG_ENDIAN_ORDER */
1201}
1202
1203WC_MISC_STATIC WC_INLINE void ato64(const byte *in, w64wrapper *w64)
1204{
1205#ifdef BIG_ENDIAN_ORDER
1206    const word32 *_in = (const word32*)(in);
1207    w64->n[0] = *_in;
1208    w64->n[1] = *(_in + 1);
1209#else
1210    ato32(in, &w64->n[0]);
1211    ato32(in + 4, &w64->n[1]);
1212#endif /* BIG_ENDIAN_ORDER */
1213}
1214
1215WC_MISC_STATIC WC_INLINE w64wrapper w64From32(word32 hi, word32 lo)
1216{
1217    w64wrapper w64;
1218    w64.n[0] = hi;
1219    w64.n[1] = lo;
1220    return w64;
1221}
1222
1223WC_MISC_STATIC WC_INLINE byte w64LT(w64wrapper a, w64wrapper b)
1224{
1225    if (a.n[0] < b.n[0])
1226        return 1;
1227    if (a.n[0] == b.n[0])
1228        return a.n[1] < b.n[1];
1229
1230    return 0;
1231}
1232
1233WC_MISC_STATIC WC_INLINE w64wrapper w64ShiftRight(w64wrapper a, int shift)
1234{
1235     if (shift < 32) {
1236         a.n[1] = (a.n[1] >> shift) | (a.n[0] << (32 - shift));
1237         a.n[0] >>= shift;
1238     }
1239     else {
1240         a.n[1] = a.n[0] >> (shift - 32);
1241         a.n[0] = 0;
1242     }
1243     return a;
1244}
1245WC_MISC_STATIC WC_INLINE w64wrapper w64ShiftLeft(w64wrapper a, int shift)
1246{
1247     if (shift < 32) {
1248         a.n[0] = (a.n[0] << shift) | (a.n[1] >> (32 - shift));
1249         a.n[1] <<= shift;
1250     }
1251     else {
1252         a.n[0] = a.n[1] << (shift - 32);
1253         a.n[1] = 0;
1254     }
1255     return a;
1256}
1257
1258WC_MISC_STATIC WC_INLINE w64wrapper w64Mul(word32 a, word32 b)
1259{
1260    w64wrapper ret;
1261    word16 ltlA, ltlB, ltlC, ltlD;
1262    word32 bigA, bigB, bigC, bigD;
1263
1264    ltlA = a & 0xFFFF;
1265    ltlB = (a >> 16) & 0xFFFF;
1266    ltlC = b & 0xFFFF;
1267    ltlD = (b >> 16) & 0xFFFF;
1268
1269    bigA = (word32)ltlA * (word32)ltlC;
1270    bigC = (word32)ltlB * (word32)ltlC;
1271    bigD = (word32)ltlA * (word32)ltlD;
1272    bigB = (word32)ltlB * (word32)ltlD;
1273
1274    ret = w64From32(0, bigB);
1275    ret = w64ShiftLeft(ret, 16);
1276    ret = w64Add32(ret, bigD, NULL);
1277    ret = w64Add32(ret, bigC, NULL);
1278    ret = w64ShiftLeft(ret, 16);
1279    return w64Add32(ret, bigA, NULL);
1280}
1281
1282#endif /* WORD64_AVAILABLE && !WOLFSSL_W64_WRAPPER_TEST */
1283#endif /* WOLFSSL_W64_WRAPPER */
1284
1285#if defined(HAVE_SESSION_TICKET) || !defined(NO_CERTS) || \
1286    !defined(NO_SESSION_CACHE)
1287/* Make a word from the front of random hash */
1288WC_MISC_STATIC WC_INLINE word32 MakeWordFromHash(const byte* hashID)
1289{
1290    return ((word32)hashID[0] << 24) | ((word32)hashID[1] << 16) |
1291           ((word32)hashID[2] <<  8) |  (word32)hashID[3];
1292}
1293#endif /* HAVE_SESSION_TICKET || !NO_CERTS || !NO_SESSION_CACHE */
1294
1295
1296#if !defined(WOLFCRYPT_ONLY) && !defined(NO_HASH_WRAPPER) && \
1297    (!defined(NO_SESSION_CACHE) || defined(HAVE_SESSION_TICKET))
1298
1299#include <wolfssl/wolfcrypt/hash.h>
1300
1301/* some session IDs aren't random after all, let's make them random */
1302WC_MISC_STATIC WC_INLINE word32 HashObject(const byte* o, word32 len,
1303                                           int* error)
1304{
1305    byte digest[WC_MAX_DIGEST_SIZE];
1306
1307#ifndef NO_MD5
1308    *error =  wc_Md5Hash(o, len, digest);
1309#elif !defined(NO_SHA)
1310    *error =  wc_ShaHash(o, len, digest);
1311#elif !defined(NO_SHA256)
1312    *error =  wc_Sha256Hash(o, len, digest);
1313#else
1314    #error "We need a digest to hash the session IDs"
1315#endif
1316
1317    return *error == 0 ? MakeWordFromHash(digest) : 0; /* 0 on failure */
1318}
1319#endif /* WOLFCRYPT_ONLY && !NO_HASH_WRAPPER &&
1320        * (!NO_SESSION_CACHE || HAVE_SESSION_TICKET) */
1321
1322WC_MISC_STATIC WC_INLINE char* CopyString(const char* src, int srcLen,
1323        void* heap, int type) {
1324    char* dst = NULL;
1325
1326    if (src == NULL)
1327        return NULL;
1328
1329    if (srcLen <= 0)
1330        srcLen = (int)XSTRLEN(src);
1331
1332    dst = (char*)XMALLOC((size_t)srcLen + 1, heap, type);
1333    if (dst != NULL) {
1334        XMEMCPY(dst, src, (size_t)srcLen);
1335        dst[srcLen] = '\0';
1336    }
1337
1338    return dst;
1339}
1340
1341#endif /* !WOLFSSL_MISC_INCLUDED && !NO_INLINE */
1342
1343#endif /* WOLF_CRYPT_MISC_C */