| /* misc.c |
| * |
| * Copyright (C) 2006-2015 wolfSSL Inc. |
| * |
| * This file is part of wolfSSL. (formerly known as CyaSSL) |
| * |
| * wolfSSL is free software; you can redistribute it and/or modify |
| * it under the terms of the GNU General Public License as published by |
| * the Free Software Foundation; either version 2 of the License, or |
| * (at your option) any later version. |
| * |
| * wolfSSL is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| * GNU General Public License for more details. |
| * |
| * You should have received a copy of the GNU General Public License |
| * along with this program; if not, write to the Free Software |
| * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA |
| */ |
| |
| #ifdef HAVE_CONFIG_H |
| #include <config.h> |
| #endif |
| |
| #include <wolfssl/wolfcrypt/settings.h> |
| |
| #ifndef WOLF_CRYPT_MISC_C |
| #define WOLF_CRYPT_MISC_C |
| |
| #include <wolfssl/wolfcrypt/misc.h> |
| |
| /* inlining these functions is a huge speed increase and a small size decrease, |
| because the functions are smaller than function call setup/cleanup, e.g., |
| md5 benchmark is twice as fast with inline. If you don't want it, then |
| define NO_INLINE and compile this file into wolfssl, otherwise it's used as |
| a source header |
| */ |
| |
| #ifdef NO_INLINE |
| #define STATIC |
| #else |
| #define STATIC static |
| #endif |
| |
| |
| #ifdef INTEL_INTRINSICS |
| |
| #include <stdlib.h> /* get intrinsic definitions */ |
| |
| /* for non visual studio probably need no long version, 32 bit only |
| * i.e., _rotl and _rotr */ |
| #pragma intrinsic(_lrotl, _lrotr) |
| |
| STATIC INLINE word32 rotlFixed(word32 x, word32 y) |
| { |
| return y ? _lrotl(x, y) : x; |
| } |
| |
| STATIC INLINE word32 rotrFixed(word32 x, word32 y) |
| { |
| return y ? _lrotr(x, y) : x; |
| } |
| |
| #else /* generic */ |
| |
| STATIC INLINE word32 rotlFixed(word32 x, word32 y) |
| { |
| return (x << y) | (x >> (sizeof(y) * 8 - y)); |
| } |
| |
| |
| STATIC INLINE word32 rotrFixed(word32 x, word32 y) |
| { |
| return (x >> y) | (x << (sizeof(y) * 8 - y)); |
| } |
| |
| #endif |
| |
| |
| STATIC INLINE word32 ByteReverseWord32(word32 value) |
| { |
| #ifdef PPC_INTRINSICS |
| /* PPC: load reverse indexed instruction */ |
| return (word32)__lwbrx(&value,0); |
| #elif defined(KEIL_INTRINSICS) |
| return (word32)__rev(value); |
| #elif defined(FAST_ROTATE) |
| /* 5 instructions with rotate instruction, 9 without */ |
| return (rotrFixed(value, 8U) & 0xff00ff00) | |
| (rotlFixed(value, 8U) & 0x00ff00ff); |
| #else |
| /* 6 instructions with rotate instruction, 8 without */ |
| value = ((value & 0xFF00FF00) >> 8) | ((value & 0x00FF00FF) << 8); |
| return rotlFixed(value, 16U); |
| #endif |
| } |
| |
| |
| STATIC INLINE void ByteReverseWords(word32* out, const word32* in, |
| word32 byteCount) |
| { |
| word32 count = byteCount/(word32)sizeof(word32), i; |
| |
| for (i = 0; i < count; i++) |
| out[i] = ByteReverseWord32(in[i]); |
| |
| } |
| |
| |
| #ifdef WORD64_AVAILABLE |
| |
| |
| STATIC INLINE word64 rotlFixed64(word64 x, word64 y) |
| { |
| return (x << y) | (x >> (sizeof(y) * 8 - y)); |
| } |
| |
| |
| STATIC INLINE word64 rotrFixed64(word64 x, word64 y) |
| { |
| return (x >> y) | (x << (sizeof(y) * 8 - y)); |
| } |
| |
| |
| STATIC INLINE word64 ByteReverseWord64(word64 value) |
| { |
| #ifdef WOLFCRYPT_SLOW_WORD64 |
| return (word64)(ByteReverseWord32((word32)value)) << 32 | |
| ByteReverseWord32((word32)(value>>32)); |
| #else |
| value = ((value & W64LIT(0xFF00FF00FF00FF00)) >> 8) | |
| ((value & W64LIT(0x00FF00FF00FF00FF)) << 8); |
| value = ((value & W64LIT(0xFFFF0000FFFF0000)) >> 16) | |
| ((value & W64LIT(0x0000FFFF0000FFFF)) << 16); |
| return rotlFixed64(value, 32U); |
| #endif |
| } |
| |
| |
| STATIC INLINE void ByteReverseWords64(word64* out, const word64* in, |
| word32 byteCount) |
| { |
| word32 count = byteCount/(word32)sizeof(word64), i; |
| |
| for (i = 0; i < count; i++) |
| out[i] = ByteReverseWord64(in[i]); |
| |
| } |
| |
| #endif /* WORD64_AVAILABLE */ |
| |
| |
| STATIC INLINE void XorWords(wolfssl_word* r, const wolfssl_word* a, word32 n) |
| { |
| word32 i; |
| |
| for (i = 0; i < n; i++) r[i] ^= a[i]; |
| } |
| |
| |
| STATIC INLINE void xorbuf(void* buf, const void* mask, word32 count) |
| { |
| if (((wolfssl_word)buf | (wolfssl_word)mask | count) % WOLFSSL_WORD_SIZE == 0) |
| XorWords( (wolfssl_word*)buf, |
| (const wolfssl_word*)mask, count / WOLFSSL_WORD_SIZE); |
| else { |
| word32 i; |
| byte* b = (byte*)buf; |
| const byte* m = (const byte*)mask; |
| |
| for (i = 0; i < count; i++) b[i] ^= m[i]; |
| } |
| } |
| |
| |
| /* Make sure compiler doesn't skip */ |
| STATIC INLINE void ForceZero(const void* mem, word32 len) |
| { |
| volatile byte* z = (volatile byte*)mem; |
| |
| while (len--) *z++ = 0; |
| } |
| |
| |
| /* check all length bytes for equality, return 0 on success */ |
| STATIC INLINE int ConstantCompare(const byte* a, const byte* b, int length) |
| { |
| int i; |
| int compareSum = 0; |
| |
| for (i = 0; i < length; i++) { |
| compareSum |= a[i] ^ b[i]; |
| } |
| |
| return compareSum; |
| } |
| |
| #undef STATIC |
| |
| #endif /* WOLF_CRYPT_MISC_C */ |