wolf SSL / wolfSSL

wolfSSL SSL/TLS library, support up to TLS1.3

Dependents:   CyaSSL-Twitter-OAuth4Tw Example-client-tls-cert TwitterReader TweetTest ... more

wolfcrypt/src/sha512.c@13:f67a6c6013ca, 2017-08-22 (annotated)

Committer:
wolfSSL
Date:
Tue Aug 22 10:48:22 2017 +0000
Revision:
13:f67a6c6013ca
wolfSSL3.12.0 with TLS1.3

Who changed what in which revision?

UserRevisionLine numberNew contents of line
wolfSSL 13:f67a6c6013ca 1 /* sha512.c
wolfSSL 13:f67a6c6013ca 2 *
wolfSSL 13:f67a6c6013ca 3 * Copyright (C) 2006-2016 wolfSSL Inc.
wolfSSL 13:f67a6c6013ca 4 *
wolfSSL 13:f67a6c6013ca 5 * This file is part of wolfSSL.
wolfSSL 13:f67a6c6013ca 6 *
wolfSSL 13:f67a6c6013ca 7 * wolfSSL is free software; you can redistribute it and/or modify
wolfSSL 13:f67a6c6013ca 8 * it under the terms of the GNU General Public License as published by
wolfSSL 13:f67a6c6013ca 9 * the Free Software Foundation; either version 2 of the License, or
wolfSSL 13:f67a6c6013ca 10 * (at your option) any later version.
wolfSSL 13:f67a6c6013ca 11 *
wolfSSL 13:f67a6c6013ca 12 * wolfSSL is distributed in the hope that it will be useful,
wolfSSL 13:f67a6c6013ca 13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
wolfSSL 13:f67a6c6013ca 14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
wolfSSL 13:f67a6c6013ca 15 * GNU General Public License for more details.
wolfSSL 13:f67a6c6013ca 16 *
wolfSSL 13:f67a6c6013ca 17 * You should have received a copy of the GNU General Public License
wolfSSL 13:f67a6c6013ca 18 * along with this program; if not, write to the Free Software
wolfSSL 13:f67a6c6013ca 19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335, USA
wolfSSL 13:f67a6c6013ca 20 */
wolfSSL 13:f67a6c6013ca 21
wolfSSL 13:f67a6c6013ca 22
wolfSSL 13:f67a6c6013ca 23 #ifdef HAVE_CONFIG_H
wolfSSL 13:f67a6c6013ca 24 #include <config.h>
wolfSSL 13:f67a6c6013ca 25 #endif
wolfSSL 13:f67a6c6013ca 26
wolfSSL 13:f67a6c6013ca 27 #include <wolfssl/wolfcrypt/settings.h>
wolfSSL 13:f67a6c6013ca 28
wolfSSL 13:f67a6c6013ca 29 #ifdef WOLFSSL_SHA512
wolfSSL 13:f67a6c6013ca 30 #include <wolfssl/wolfcrypt/sha512.h>
wolfSSL 13:f67a6c6013ca 31 #include <wolfssl/wolfcrypt/error-crypt.h>
wolfSSL 13:f67a6c6013ca 32 #include <wolfssl/wolfcrypt/cpuid.h>
wolfSSL 13:f67a6c6013ca 33
wolfSSL 13:f67a6c6013ca 34 /* fips wrapper calls, user can call direct */
wolfSSL 13:f67a6c6013ca 35 #ifdef HAVE_FIPS
wolfSSL 13:f67a6c6013ca 36 int wc_InitSha512(Sha512* sha)
wolfSSL 13:f67a6c6013ca 37 {
wolfSSL 13:f67a6c6013ca 38 if (sha == NULL) {
wolfSSL 13:f67a6c6013ca 39 return BAD_FUNC_ARG;
wolfSSL 13:f67a6c6013ca 40 }
wolfSSL 13:f67a6c6013ca 41
wolfSSL 13:f67a6c6013ca 42 return InitSha512_fips(sha);
wolfSSL 13:f67a6c6013ca 43 }
wolfSSL 13:f67a6c6013ca 44 int wc_InitSha512_ex(Sha512* sha, void* heap, int devId)
wolfSSL 13:f67a6c6013ca 45 {
wolfSSL 13:f67a6c6013ca 46 (void)heap;
wolfSSL 13:f67a6c6013ca 47 (void)devId;
wolfSSL 13:f67a6c6013ca 48 if (sha == NULL) {
wolfSSL 13:f67a6c6013ca 49 return BAD_FUNC_ARG;
wolfSSL 13:f67a6c6013ca 50 }
wolfSSL 13:f67a6c6013ca 51 return InitSha512_fips(sha);
wolfSSL 13:f67a6c6013ca 52 }
wolfSSL 13:f67a6c6013ca 53 int wc_Sha512Update(Sha512* sha, const byte* data, word32 len)
wolfSSL 13:f67a6c6013ca 54 {
wolfSSL 13:f67a6c6013ca 55 if (sha == NULL || (data == NULL && len > 0)) {
wolfSSL 13:f67a6c6013ca 56 return BAD_FUNC_ARG;
wolfSSL 13:f67a6c6013ca 57 }
wolfSSL 13:f67a6c6013ca 58
wolfSSL 13:f67a6c6013ca 59 return Sha512Update_fips(sha, data, len);
wolfSSL 13:f67a6c6013ca 60 }
wolfSSL 13:f67a6c6013ca 61 int wc_Sha512Final(Sha512* sha, byte* out)
wolfSSL 13:f67a6c6013ca 62 {
wolfSSL 13:f67a6c6013ca 63 if (sha == NULL || out == NULL) {
wolfSSL 13:f67a6c6013ca 64 return BAD_FUNC_ARG;
wolfSSL 13:f67a6c6013ca 65 }
wolfSSL 13:f67a6c6013ca 66
wolfSSL 13:f67a6c6013ca 67 return Sha512Final_fips(sha, out);
wolfSSL 13:f67a6c6013ca 68 }
wolfSSL 13:f67a6c6013ca 69 void wc_Sha512Free(Sha512* sha)
wolfSSL 13:f67a6c6013ca 70 {
wolfSSL 13:f67a6c6013ca 71 (void)sha;
wolfSSL 13:f67a6c6013ca 72 /* Not supported in FIPS */
wolfSSL 13:f67a6c6013ca 73 }
wolfSSL 13:f67a6c6013ca 74
wolfSSL 13:f67a6c6013ca 75 #if defined(WOLFSSL_SHA384) || defined(HAVE_AESGCM)
wolfSSL 13:f67a6c6013ca 76 int wc_InitSha384(Sha384* sha)
wolfSSL 13:f67a6c6013ca 77 {
wolfSSL 13:f67a6c6013ca 78 if (sha == NULL) {
wolfSSL 13:f67a6c6013ca 79 return BAD_FUNC_ARG;
wolfSSL 13:f67a6c6013ca 80 }
wolfSSL 13:f67a6c6013ca 81 return InitSha384_fips(sha);
wolfSSL 13:f67a6c6013ca 82 }
wolfSSL 13:f67a6c6013ca 83 int wc_InitSha384_ex(Sha384* sha, void* heap, int devId)
wolfSSL 13:f67a6c6013ca 84 {
wolfSSL 13:f67a6c6013ca 85 (void)heap;
wolfSSL 13:f67a6c6013ca 86 (void)devId;
wolfSSL 13:f67a6c6013ca 87 if (sha == NULL) {
wolfSSL 13:f67a6c6013ca 88 return BAD_FUNC_ARG;
wolfSSL 13:f67a6c6013ca 89 }
wolfSSL 13:f67a6c6013ca 90 return InitSha384_fips(sha);
wolfSSL 13:f67a6c6013ca 91 }
wolfSSL 13:f67a6c6013ca 92 int wc_Sha384Update(Sha384* sha, const byte* data, word32 len)
wolfSSL 13:f67a6c6013ca 93 {
wolfSSL 13:f67a6c6013ca 94 if (sha == NULL || (data == NULL && len > 0)) {
wolfSSL 13:f67a6c6013ca 95 return BAD_FUNC_ARG;
wolfSSL 13:f67a6c6013ca 96 }
wolfSSL 13:f67a6c6013ca 97 return Sha384Update_fips(sha, data, len);
wolfSSL 13:f67a6c6013ca 98 }
wolfSSL 13:f67a6c6013ca 99 int wc_Sha384Final(Sha384* sha, byte* out)
wolfSSL 13:f67a6c6013ca 100 {
wolfSSL 13:f67a6c6013ca 101 if (sha == NULL || out == NULL) {
wolfSSL 13:f67a6c6013ca 102 return BAD_FUNC_ARG;
wolfSSL 13:f67a6c6013ca 103 }
wolfSSL 13:f67a6c6013ca 104 return Sha384Final_fips(sha, out);
wolfSSL 13:f67a6c6013ca 105 }
wolfSSL 13:f67a6c6013ca 106 void wc_Sha384Free(Sha384* sha)
wolfSSL 13:f67a6c6013ca 107 {
wolfSSL 13:f67a6c6013ca 108 (void)sha;
wolfSSL 13:f67a6c6013ca 109 /* Not supported in FIPS */
wolfSSL 13:f67a6c6013ca 110 }
wolfSSL 13:f67a6c6013ca 111 #endif /* WOLFSSL_SHA384 || HAVE_AESGCM */
wolfSSL 13:f67a6c6013ca 112
wolfSSL 13:f67a6c6013ca 113 #else /* else build without using fips */
wolfSSL 13:f67a6c6013ca 114
wolfSSL 13:f67a6c6013ca 115 #include <wolfssl/wolfcrypt/logging.h>
wolfSSL 13:f67a6c6013ca 116
wolfSSL 13:f67a6c6013ca 117 #ifdef NO_INLINE
wolfSSL 13:f67a6c6013ca 118 #include <wolfssl/wolfcrypt/misc.h>
wolfSSL 13:f67a6c6013ca 119 #else
wolfSSL 13:f67a6c6013ca 120 #define WOLFSSL_MISC_INCLUDED
wolfSSL 13:f67a6c6013ca 121 #include <wolfcrypt/src/misc.c>
wolfSSL 13:f67a6c6013ca 122 #endif
wolfSSL 13:f67a6c6013ca 123
wolfSSL 13:f67a6c6013ca 124
wolfSSL 13:f67a6c6013ca 125 #if defined(USE_INTEL_SPEEDUP)
wolfSSL 13:f67a6c6013ca 126 #define HAVE_INTEL_AVX1
wolfSSL 13:f67a6c6013ca 127 #define HAVE_INTEL_AVX2
wolfSSL 13:f67a6c6013ca 128 #endif
wolfSSL 13:f67a6c6013ca 129
wolfSSL 13:f67a6c6013ca 130 #if defined(HAVE_INTEL_AVX1)
wolfSSL 13:f67a6c6013ca 131 /* #define DEBUG_XMM */
wolfSSL 13:f67a6c6013ca 132 #endif
wolfSSL 13:f67a6c6013ca 133
wolfSSL 13:f67a6c6013ca 134 #if defined(HAVE_INTEL_AVX2)
wolfSSL 13:f67a6c6013ca 135 #define HAVE_INTEL_RORX
wolfSSL 13:f67a6c6013ca 136 /* #define DEBUG_YMM */
wolfSSL 13:f67a6c6013ca 137 #endif
wolfSSL 13:f67a6c6013ca 138
wolfSSL 13:f67a6c6013ca 139
wolfSSL 13:f67a6c6013ca 140 #if defined(HAVE_INTEL_RORX)
wolfSSL 13:f67a6c6013ca 141 #define ROTR(func, bits, x) \
wolfSSL 13:f67a6c6013ca 142 word64 func(word64 x) { word64 ret ;\
wolfSSL 13:f67a6c6013ca 143 __asm__ ("rorx $"#bits", %1, %0\n\t":"=r"(ret):"r"(x):) ;\
wolfSSL 13:f67a6c6013ca 144 return ret ;\
wolfSSL 13:f67a6c6013ca 145 }
wolfSSL 13:f67a6c6013ca 146
wolfSSL 13:f67a6c6013ca 147 static INLINE ROTR(rotrFixed64_28, 28, x);
wolfSSL 13:f67a6c6013ca 148 static INLINE ROTR(rotrFixed64_34, 34, x);
wolfSSL 13:f67a6c6013ca 149 static INLINE ROTR(rotrFixed64_39, 39, x);
wolfSSL 13:f67a6c6013ca 150 static INLINE ROTR(rotrFixed64_14, 14, x);
wolfSSL 13:f67a6c6013ca 151 static INLINE ROTR(rotrFixed64_18, 18, x);
wolfSSL 13:f67a6c6013ca 152 static INLINE ROTR(rotrFixed64_41, 41, x);
wolfSSL 13:f67a6c6013ca 153
wolfSSL 13:f67a6c6013ca 154 #define S0_RORX(x) (rotrFixed64_28(x)^rotrFixed64_34(x)^rotrFixed64_39(x))
wolfSSL 13:f67a6c6013ca 155 #define S1_RORX(x) (rotrFixed64_14(x)^rotrFixed64_18(x)^rotrFixed64_41(x))
wolfSSL 13:f67a6c6013ca 156 #endif /* HAVE_INTEL_RORX */
wolfSSL 13:f67a6c6013ca 157
wolfSSL 13:f67a6c6013ca 158 #if defined(HAVE_BYTEREVERSE64) && \
wolfSSL 13:f67a6c6013ca 159 !defined(HAVE_INTEL_AVX1) && !defined(HAVE_INTEL_AVX2)
wolfSSL 13:f67a6c6013ca 160 #define ByteReverseWords64(out, in, size) ByteReverseWords64_1(out, size)
wolfSSL 13:f67a6c6013ca 161 #define ByteReverseWords64_1(buf, size) \
wolfSSL 13:f67a6c6013ca 162 { unsigned int i ;\
wolfSSL 13:f67a6c6013ca 163 for(i=0; i< size/sizeof(word64); i++){\
wolfSSL 13:f67a6c6013ca 164 __asm__ volatile("bswapq %0":"+r"(buf[i])::) ;\
wolfSSL 13:f67a6c6013ca 165 }\
wolfSSL 13:f67a6c6013ca 166 }
wolfSSL 13:f67a6c6013ca 167 #endif
wolfSSL 13:f67a6c6013ca 168
wolfSSL 13:f67a6c6013ca 169 static int InitSha512(Sha512* sha512)
wolfSSL 13:f67a6c6013ca 170 {
wolfSSL 13:f67a6c6013ca 171 if (sha512 == NULL)
wolfSSL 13:f67a6c6013ca 172 return BAD_FUNC_ARG;
wolfSSL 13:f67a6c6013ca 173
wolfSSL 13:f67a6c6013ca 174 sha512->digest[0] = W64LIT(0x6a09e667f3bcc908);
wolfSSL 13:f67a6c6013ca 175 sha512->digest[1] = W64LIT(0xbb67ae8584caa73b);
wolfSSL 13:f67a6c6013ca 176 sha512->digest[2] = W64LIT(0x3c6ef372fe94f82b);
wolfSSL 13:f67a6c6013ca 177 sha512->digest[3] = W64LIT(0xa54ff53a5f1d36f1);
wolfSSL 13:f67a6c6013ca 178 sha512->digest[4] = W64LIT(0x510e527fade682d1);
wolfSSL 13:f67a6c6013ca 179 sha512->digest[5] = W64LIT(0x9b05688c2b3e6c1f);
wolfSSL 13:f67a6c6013ca 180 sha512->digest[6] = W64LIT(0x1f83d9abfb41bd6b);
wolfSSL 13:f67a6c6013ca 181 sha512->digest[7] = W64LIT(0x5be0cd19137e2179);
wolfSSL 13:f67a6c6013ca 182
wolfSSL 13:f67a6c6013ca 183 sha512->buffLen = 0;
wolfSSL 13:f67a6c6013ca 184 sha512->loLen = 0;
wolfSSL 13:f67a6c6013ca 185 sha512->hiLen = 0;
wolfSSL 13:f67a6c6013ca 186
wolfSSL 13:f67a6c6013ca 187 return 0;
wolfSSL 13:f67a6c6013ca 188 }
wolfSSL 13:f67a6c6013ca 189
wolfSSL 13:f67a6c6013ca 190
wolfSSL 13:f67a6c6013ca 191 /* Hardware Acceleration */
wolfSSL 13:f67a6c6013ca 192 #if defined(HAVE_INTEL_AVX1) || defined(HAVE_INTEL_AVX2)
wolfSSL 13:f67a6c6013ca 193
wolfSSL 13:f67a6c6013ca 194 /*****
wolfSSL 13:f67a6c6013ca 195 Intel AVX1/AVX2 Macro Control Structure
wolfSSL 13:f67a6c6013ca 196
wolfSSL 13:f67a6c6013ca 197 #if defined(HAVE_INteL_SPEEDUP)
wolfSSL 13:f67a6c6013ca 198 #define HAVE_INTEL_AVX1
wolfSSL 13:f67a6c6013ca 199 #define HAVE_INTEL_AVX2
wolfSSL 13:f67a6c6013ca 200 #endif
wolfSSL 13:f67a6c6013ca 201
wolfSSL 13:f67a6c6013ca 202 int InitSha512(Sha512* sha512) {
wolfSSL 13:f67a6c6013ca 203 Save/Recover XMM, YMM
wolfSSL 13:f67a6c6013ca 204 ...
wolfSSL 13:f67a6c6013ca 205
wolfSSL 13:f67a6c6013ca 206 Check Intel AVX cpuid flags
wolfSSL 13:f67a6c6013ca 207 }
wolfSSL 13:f67a6c6013ca 208
wolfSSL 13:f67a6c6013ca 209 #if defined(HAVE_INTEL_AVX1)|| defined(HAVE_INTEL_AVX2)
wolfSSL 13:f67a6c6013ca 210 Transform_AVX1(); # Function prototype
wolfSSL 13:f67a6c6013ca 211 Transform_AVX2(); #
wolfSSL 13:f67a6c6013ca 212 #endif
wolfSSL 13:f67a6c6013ca 213
wolfSSL 13:f67a6c6013ca 214 _Transform() { # Native Transform Function body
wolfSSL 13:f67a6c6013ca 215
wolfSSL 13:f67a6c6013ca 216 }
wolfSSL 13:f67a6c6013ca 217
wolfSSL 13:f67a6c6013ca 218 int Sha512Update() {
wolfSSL 13:f67a6c6013ca 219 Save/Recover XMM, YMM
wolfSSL 13:f67a6c6013ca 220 ...
wolfSSL 13:f67a6c6013ca 221 }
wolfSSL 13:f67a6c6013ca 222
wolfSSL 13:f67a6c6013ca 223 int Sha512Final() {
wolfSSL 13:f67a6c6013ca 224 Save/Recover XMM, YMM
wolfSSL 13:f67a6c6013ca 225 ...
wolfSSL 13:f67a6c6013ca 226 }
wolfSSL 13:f67a6c6013ca 227
wolfSSL 13:f67a6c6013ca 228
wolfSSL 13:f67a6c6013ca 229 #if defined(HAVE_INTEL_AVX1)
wolfSSL 13:f67a6c6013ca 230
wolfSSL 13:f67a6c6013ca 231 XMM Instructions/INLINE asm Definitions
wolfSSL 13:f67a6c6013ca 232
wolfSSL 13:f67a6c6013ca 233 #endif
wolfSSL 13:f67a6c6013ca 234
wolfSSL 13:f67a6c6013ca 235 #if defined(HAVE_INTEL_AVX2)
wolfSSL 13:f67a6c6013ca 236
wolfSSL 13:f67a6c6013ca 237 YMM Instructions/INLINE asm Definitions
wolfSSL 13:f67a6c6013ca 238
wolfSSL 13:f67a6c6013ca 239 #endif
wolfSSL 13:f67a6c6013ca 240
wolfSSL 13:f67a6c6013ca 241 #if defnied(HAVE_INTEL_AVX1)
wolfSSL 13:f67a6c6013ca 242
wolfSSL 13:f67a6c6013ca 243 int Transform_AVX1() {
wolfSSL 13:f67a6c6013ca 244 Stitched Message Sched/Round
wolfSSL 13:f67a6c6013ca 245 }
wolfSSL 13:f67a6c6013ca 246
wolfSSL 13:f67a6c6013ca 247 #endif
wolfSSL 13:f67a6c6013ca 248
wolfSSL 13:f67a6c6013ca 249 #if defnied(HAVE_INTEL_AVX2)
wolfSSL 13:f67a6c6013ca 250
wolfSSL 13:f67a6c6013ca 251 int Transform_AVX2() {
wolfSSL 13:f67a6c6013ca 252 Stitched Message Sched/Round
wolfSSL 13:f67a6c6013ca 253 }
wolfSSL 13:f67a6c6013ca 254 #endif
wolfSSL 13:f67a6c6013ca 255
wolfSSL 13:f67a6c6013ca 256 */
wolfSSL 13:f67a6c6013ca 257
wolfSSL 13:f67a6c6013ca 258
wolfSSL 13:f67a6c6013ca 259 /* Each platform needs to query info type 1 from cpuid to see if aesni is
wolfSSL 13:f67a6c6013ca 260 * supported. Also, let's setup a macro for proper linkage w/o ABI conflicts
wolfSSL 13:f67a6c6013ca 261 */
wolfSSL 13:f67a6c6013ca 262
wolfSSL 13:f67a6c6013ca 263 #if defined(HAVE_INTEL_AVX1)
wolfSSL 13:f67a6c6013ca 264 static int Transform_AVX1(Sha512 *sha512);
wolfSSL 13:f67a6c6013ca 265 #endif
wolfSSL 13:f67a6c6013ca 266 #if defined(HAVE_INTEL_AVX2)
wolfSSL 13:f67a6c6013ca 267 static int Transform_AVX2(Sha512 *sha512);
wolfSSL 13:f67a6c6013ca 268 #if defined(HAVE_INTEL_AVX1) && defined(HAVE_INTEL_AVX2) && defined(HAVE_INTEL_RORX)
wolfSSL 13:f67a6c6013ca 269 static int Transform_AVX1_RORX(Sha512 *sha512);
wolfSSL 13:f67a6c6013ca 270 #endif
wolfSSL 13:f67a6c6013ca 271 #endif
wolfSSL 13:f67a6c6013ca 272 static int _Transform(Sha512 *sha512);
wolfSSL 13:f67a6c6013ca 273 static int (*Transform_p)(Sha512* sha512) = _Transform;
wolfSSL 13:f67a6c6013ca 274 static int transform_check = 0;
wolfSSL 13:f67a6c6013ca 275 static int intel_flags;
wolfSSL 13:f67a6c6013ca 276 #define Transform(sha512) (*Transform_p)(sha512)
wolfSSL 13:f67a6c6013ca 277
wolfSSL 13:f67a6c6013ca 278 /* Dummy for saving MM_REGs on behalf of Transform */
wolfSSL 13:f67a6c6013ca 279 /* #if defined(HAVE_INTEL_AVX2)
wolfSSL 13:f67a6c6013ca 280 #define SAVE_XMM_YMM __asm__ volatile("orq %%r8, %%r8":::\
wolfSSL 13:f67a6c6013ca 281 "%ymm0","%ymm1","%ymm2","%ymm3","%ymm4","%ymm5","%ymm6","%ymm7","%ymm8","%ymm9","%ymm10","%ymm11",\
wolfSSL 13:f67a6c6013ca 282 "%ymm12","%ymm13","%ymm14","%ymm15")
wolfSSL 13:f67a6c6013ca 283 */
wolfSSL 13:f67a6c6013ca 284 #if defined(HAVE_INTEL_AVX1)
wolfSSL 13:f67a6c6013ca 285 #define SAVE_XMM_YMM __asm__ volatile("orq %%r8, %%r8":::\
wolfSSL 13:f67a6c6013ca 286 "xmm0","xmm1","xmm2","xmm3","xmm4","xmm5","xmm6","xmm7","xmm8","xmm9","xmm10","xmm11","xmm12","xmm13","xmm14","xmm15")
wolfSSL 13:f67a6c6013ca 287 #endif
wolfSSL 13:f67a6c6013ca 288
wolfSSL 13:f67a6c6013ca 289 static void Sha512_SetTransform()
wolfSSL 13:f67a6c6013ca 290 {
wolfSSL 13:f67a6c6013ca 291 if (transform_check)
wolfSSL 13:f67a6c6013ca 292 return;
wolfSSL 13:f67a6c6013ca 293
wolfSSL 13:f67a6c6013ca 294 intel_flags = cpuid_get_flags();
wolfSSL 13:f67a6c6013ca 295
wolfSSL 13:f67a6c6013ca 296 #if defined(HAVE_INTEL_AVX2)
wolfSSL 13:f67a6c6013ca 297 if (IS_INTEL_AVX2(intel_flags) && IS_INTEL_BMI2(intel_flags)) {
wolfSSL 13:f67a6c6013ca 298 if (1)
wolfSSL 13:f67a6c6013ca 299 Transform_p = Transform_AVX1_RORX;
wolfSSL 13:f67a6c6013ca 300 else
wolfSSL 13:f67a6c6013ca 301 Transform_p = Transform_AVX2;
wolfSSL 13:f67a6c6013ca 302 }
wolfSSL 13:f67a6c6013ca 303 else
wolfSSL 13:f67a6c6013ca 304 #endif
wolfSSL 13:f67a6c6013ca 305 #if defined(HAVE_INTEL_AVX1)
wolfSSL 13:f67a6c6013ca 306 if (1) {
wolfSSL 13:f67a6c6013ca 307 Transform_p = ((IS_INTEL_AVX1(intel_flags)) ? Transform_AVX1 :
wolfSSL 13:f67a6c6013ca 308 _Transform);
wolfSSL 13:f67a6c6013ca 309 }
wolfSSL 13:f67a6c6013ca 310 else
wolfSSL 13:f67a6c6013ca 311 #endif
wolfSSL 13:f67a6c6013ca 312 Transform_p = _Transform;
wolfSSL 13:f67a6c6013ca 313
wolfSSL 13:f67a6c6013ca 314 transform_check = 1;
wolfSSL 13:f67a6c6013ca 315 }
wolfSSL 13:f67a6c6013ca 316
wolfSSL 13:f67a6c6013ca 317 int wc_InitSha512_ex(Sha512* sha512, void* heap, int devId)
wolfSSL 13:f67a6c6013ca 318 {
wolfSSL 13:f67a6c6013ca 319 int ret = InitSha512(sha512);
wolfSSL 13:f67a6c6013ca 320
wolfSSL 13:f67a6c6013ca 321 (void)heap;
wolfSSL 13:f67a6c6013ca 322 (void)devId;
wolfSSL 13:f67a6c6013ca 323
wolfSSL 13:f67a6c6013ca 324 Sha512_SetTransform();
wolfSSL 13:f67a6c6013ca 325
wolfSSL 13:f67a6c6013ca 326 return ret;
wolfSSL 13:f67a6c6013ca 327 }
wolfSSL 13:f67a6c6013ca 328
wolfSSL 13:f67a6c6013ca 329 #else
wolfSSL 13:f67a6c6013ca 330 #define Transform(sha512) _Transform(sha512)
wolfSSL 13:f67a6c6013ca 331
wolfSSL 13:f67a6c6013ca 332 int wc_InitSha512_ex(Sha512* sha512, void* heap, int devId)
wolfSSL 13:f67a6c6013ca 333 {
wolfSSL 13:f67a6c6013ca 334 int ret = 0;
wolfSSL 13:f67a6c6013ca 335
wolfSSL 13:f67a6c6013ca 336 if (sha512 == NULL)
wolfSSL 13:f67a6c6013ca 337 return BAD_FUNC_ARG;
wolfSSL 13:f67a6c6013ca 338
wolfSSL 13:f67a6c6013ca 339 sha512->heap = heap;
wolfSSL 13:f67a6c6013ca 340
wolfSSL 13:f67a6c6013ca 341 ret = InitSha512(sha512);
wolfSSL 13:f67a6c6013ca 342 if (ret != 0)
wolfSSL 13:f67a6c6013ca 343 return ret;
wolfSSL 13:f67a6c6013ca 344
wolfSSL 13:f67a6c6013ca 345 #if defined(WOLFSSL_ASYNC_CRYPT) && defined(WC_ASYNC_ENABLE_SHA512)
wolfSSL 13:f67a6c6013ca 346 ret = wolfAsync_DevCtxInit(&sha512->asyncDev,
wolfSSL 13:f67a6c6013ca 347 WOLFSSL_ASYNC_MARKER_SHA512, sha512->heap, devId);
wolfSSL 13:f67a6c6013ca 348 #else
wolfSSL 13:f67a6c6013ca 349 (void)devId;
wolfSSL 13:f67a6c6013ca 350 #endif /* WOLFSSL_ASYNC_CRYPT */
wolfSSL 13:f67a6c6013ca 351
wolfSSL 13:f67a6c6013ca 352 return ret;
wolfSSL 13:f67a6c6013ca 353 }
wolfSSL 13:f67a6c6013ca 354
wolfSSL 13:f67a6c6013ca 355 #endif /* Hardware Acceleration */
wolfSSL 13:f67a6c6013ca 356
wolfSSL 13:f67a6c6013ca 357 #ifndef SAVE_XMM_YMM
wolfSSL 13:f67a6c6013ca 358 #define SAVE_XMM_YMM
wolfSSL 13:f67a6c6013ca 359 #endif
wolfSSL 13:f67a6c6013ca 360
wolfSSL 13:f67a6c6013ca 361 static const word64 K512[80] = {
wolfSSL 13:f67a6c6013ca 362 W64LIT(0x428a2f98d728ae22), W64LIT(0x7137449123ef65cd),
wolfSSL 13:f67a6c6013ca 363 W64LIT(0xb5c0fbcfec4d3b2f), W64LIT(0xe9b5dba58189dbbc),
wolfSSL 13:f67a6c6013ca 364 W64LIT(0x3956c25bf348b538), W64LIT(0x59f111f1b605d019),
wolfSSL 13:f67a6c6013ca 365 W64LIT(0x923f82a4af194f9b), W64LIT(0xab1c5ed5da6d8118),
wolfSSL 13:f67a6c6013ca 366 W64LIT(0xd807aa98a3030242), W64LIT(0x12835b0145706fbe),
wolfSSL 13:f67a6c6013ca 367 W64LIT(0x243185be4ee4b28c), W64LIT(0x550c7dc3d5ffb4e2),
wolfSSL 13:f67a6c6013ca 368 W64LIT(0x72be5d74f27b896f), W64LIT(0x80deb1fe3b1696b1),
wolfSSL 13:f67a6c6013ca 369 W64LIT(0x9bdc06a725c71235), W64LIT(0xc19bf174cf692694),
wolfSSL 13:f67a6c6013ca 370 W64LIT(0xe49b69c19ef14ad2), W64LIT(0xefbe4786384f25e3),
wolfSSL 13:f67a6c6013ca 371 W64LIT(0x0fc19dc68b8cd5b5), W64LIT(0x240ca1cc77ac9c65),
wolfSSL 13:f67a6c6013ca 372 W64LIT(0x2de92c6f592b0275), W64LIT(0x4a7484aa6ea6e483),
wolfSSL 13:f67a6c6013ca 373 W64LIT(0x5cb0a9dcbd41fbd4), W64LIT(0x76f988da831153b5),
wolfSSL 13:f67a6c6013ca 374 W64LIT(0x983e5152ee66dfab), W64LIT(0xa831c66d2db43210),
wolfSSL 13:f67a6c6013ca 375 W64LIT(0xb00327c898fb213f), W64LIT(0xbf597fc7beef0ee4),
wolfSSL 13:f67a6c6013ca 376 W64LIT(0xc6e00bf33da88fc2), W64LIT(0xd5a79147930aa725),
wolfSSL 13:f67a6c6013ca 377 W64LIT(0x06ca6351e003826f), W64LIT(0x142929670a0e6e70),
wolfSSL 13:f67a6c6013ca 378 W64LIT(0x27b70a8546d22ffc), W64LIT(0x2e1b21385c26c926),
wolfSSL 13:f67a6c6013ca 379 W64LIT(0x4d2c6dfc5ac42aed), W64LIT(0x53380d139d95b3df),
wolfSSL 13:f67a6c6013ca 380 W64LIT(0x650a73548baf63de), W64LIT(0x766a0abb3c77b2a8),
wolfSSL 13:f67a6c6013ca 381 W64LIT(0x81c2c92e47edaee6), W64LIT(0x92722c851482353b),
wolfSSL 13:f67a6c6013ca 382 W64LIT(0xa2bfe8a14cf10364), W64LIT(0xa81a664bbc423001),
wolfSSL 13:f67a6c6013ca 383 W64LIT(0xc24b8b70d0f89791), W64LIT(0xc76c51a30654be30),
wolfSSL 13:f67a6c6013ca 384 W64LIT(0xd192e819d6ef5218), W64LIT(0xd69906245565a910),
wolfSSL 13:f67a6c6013ca 385 W64LIT(0xf40e35855771202a), W64LIT(0x106aa07032bbd1b8),
wolfSSL 13:f67a6c6013ca 386 W64LIT(0x19a4c116b8d2d0c8), W64LIT(0x1e376c085141ab53),
wolfSSL 13:f67a6c6013ca 387 W64LIT(0x2748774cdf8eeb99), W64LIT(0x34b0bcb5e19b48a8),
wolfSSL 13:f67a6c6013ca 388 W64LIT(0x391c0cb3c5c95a63), W64LIT(0x4ed8aa4ae3418acb),
wolfSSL 13:f67a6c6013ca 389 W64LIT(0x5b9cca4f7763e373), W64LIT(0x682e6ff3d6b2b8a3),
wolfSSL 13:f67a6c6013ca 390 W64LIT(0x748f82ee5defb2fc), W64LIT(0x78a5636f43172f60),
wolfSSL 13:f67a6c6013ca 391 W64LIT(0x84c87814a1f0ab72), W64LIT(0x8cc702081a6439ec),
wolfSSL 13:f67a6c6013ca 392 W64LIT(0x90befffa23631e28), W64LIT(0xa4506cebde82bde9),
wolfSSL 13:f67a6c6013ca 393 W64LIT(0xbef9a3f7b2c67915), W64LIT(0xc67178f2e372532b),
wolfSSL 13:f67a6c6013ca 394 W64LIT(0xca273eceea26619c), W64LIT(0xd186b8c721c0c207),
wolfSSL 13:f67a6c6013ca 395 W64LIT(0xeada7dd6cde0eb1e), W64LIT(0xf57d4f7fee6ed178),
wolfSSL 13:f67a6c6013ca 396 W64LIT(0x06f067aa72176fba), W64LIT(0x0a637dc5a2c898a6),
wolfSSL 13:f67a6c6013ca 397 W64LIT(0x113f9804bef90dae), W64LIT(0x1b710b35131c471b),
wolfSSL 13:f67a6c6013ca 398 W64LIT(0x28db77f523047d84), W64LIT(0x32caab7b40c72493),
wolfSSL 13:f67a6c6013ca 399 W64LIT(0x3c9ebe0a15c9bebc), W64LIT(0x431d67c49c100d4c),
wolfSSL 13:f67a6c6013ca 400 W64LIT(0x4cc5d4becb3e42b6), W64LIT(0x597f299cfc657e2a),
wolfSSL 13:f67a6c6013ca 401 W64LIT(0x5fcb6fab3ad6faec), W64LIT(0x6c44198c4a475817)
wolfSSL 13:f67a6c6013ca 402 };
wolfSSL 13:f67a6c6013ca 403
wolfSSL 13:f67a6c6013ca 404
wolfSSL 13:f67a6c6013ca 405
wolfSSL 13:f67a6c6013ca 406 #define blk0(i) (W[i] = sha512->buffer[i])
wolfSSL 13:f67a6c6013ca 407
wolfSSL 13:f67a6c6013ca 408 #define blk2(i) (W[i&15]+=s1(W[(i-2)&15])+W[(i-7)&15]+s0(W[(i-15)&15]))
wolfSSL 13:f67a6c6013ca 409
wolfSSL 13:f67a6c6013ca 410 #define Ch(x,y,z) (z^(x&(y^z)))
wolfSSL 13:f67a6c6013ca 411 #define Maj(x,y,z) ((x&y)|(z&(x|y)))
wolfSSL 13:f67a6c6013ca 412
wolfSSL 13:f67a6c6013ca 413 #define a(i) T[(0-i)&7]
wolfSSL 13:f67a6c6013ca 414 #define b(i) T[(1-i)&7]
wolfSSL 13:f67a6c6013ca 415 #define c(i) T[(2-i)&7]
wolfSSL 13:f67a6c6013ca 416 #define d(i) T[(3-i)&7]
wolfSSL 13:f67a6c6013ca 417 #define e(i) T[(4-i)&7]
wolfSSL 13:f67a6c6013ca 418 #define f(i) T[(5-i)&7]
wolfSSL 13:f67a6c6013ca 419 #define g(i) T[(6-i)&7]
wolfSSL 13:f67a6c6013ca 420 #define h(i) T[(7-i)&7]
wolfSSL 13:f67a6c6013ca 421
wolfSSL 13:f67a6c6013ca 422 #define S0(x) (rotrFixed64(x,28)^rotrFixed64(x,34)^rotrFixed64(x,39))
wolfSSL 13:f67a6c6013ca 423 #define S1(x) (rotrFixed64(x,14)^rotrFixed64(x,18)^rotrFixed64(x,41))
wolfSSL 13:f67a6c6013ca 424 #define s0(x) (rotrFixed64(x,1)^rotrFixed64(x,8)^(x>>7))
wolfSSL 13:f67a6c6013ca 425 #define s1(x) (rotrFixed64(x,19)^rotrFixed64(x,61)^(x>>6))
wolfSSL 13:f67a6c6013ca 426
wolfSSL 13:f67a6c6013ca 427 #define R(i) h(i)+=S1(e(i))+Ch(e(i),f(i),g(i))+K[i+j]+(j?blk2(i):blk0(i));\
wolfSSL 13:f67a6c6013ca 428 d(i)+=h(i);h(i)+=S0(a(i))+Maj(a(i),b(i),c(i))
wolfSSL 13:f67a6c6013ca 429
wolfSSL 13:f67a6c6013ca 430 static int _Transform(Sha512* sha512)
wolfSSL 13:f67a6c6013ca 431 {
wolfSSL 13:f67a6c6013ca 432 const word64* K = K512;
wolfSSL 13:f67a6c6013ca 433
wolfSSL 13:f67a6c6013ca 434 word32 j;
wolfSSL 13:f67a6c6013ca 435 word64 T[8];
wolfSSL 13:f67a6c6013ca 436
wolfSSL 13:f67a6c6013ca 437
wolfSSL 13:f67a6c6013ca 438 #ifdef WOLFSSL_SMALL_STACK
wolfSSL 13:f67a6c6013ca 439 word64* W;
wolfSSL 13:f67a6c6013ca 440 W = (word64*) XMALLOC(sizeof(word64) * 16, NULL, DYNAMIC_TYPE_TMP_BUFFER);
wolfSSL 13:f67a6c6013ca 441 if (W == NULL)
wolfSSL 13:f67a6c6013ca 442 return MEMORY_E;
wolfSSL 13:f67a6c6013ca 443 #else
wolfSSL 13:f67a6c6013ca 444 word64 W[16];
wolfSSL 13:f67a6c6013ca 445 #endif
wolfSSL 13:f67a6c6013ca 446
wolfSSL 13:f67a6c6013ca 447 /* Copy digest to working vars */
wolfSSL 13:f67a6c6013ca 448 XMEMCPY(T, sha512->digest, sizeof(T));
wolfSSL 13:f67a6c6013ca 449
wolfSSL 13:f67a6c6013ca 450 #ifdef USE_SLOW_SHA2
wolfSSL 13:f67a6c6013ca 451 /* over twice as small, but 50% slower */
wolfSSL 13:f67a6c6013ca 452 /* 80 operations, not unrolled */
wolfSSL 13:f67a6c6013ca 453 for (j = 0; j < 80; j += 16) {
wolfSSL 13:f67a6c6013ca 454 int m;
wolfSSL 13:f67a6c6013ca 455 for (m = 0; m < 16; m++) { /* braces needed here for macros {} */
wolfSSL 13:f67a6c6013ca 456 R(m);
wolfSSL 13:f67a6c6013ca 457 }
wolfSSL 13:f67a6c6013ca 458 }
wolfSSL 13:f67a6c6013ca 459 #else
wolfSSL 13:f67a6c6013ca 460 /* 80 operations, partially loop unrolled */
wolfSSL 13:f67a6c6013ca 461 for (j = 0; j < 80; j += 16) {
wolfSSL 13:f67a6c6013ca 462 R( 0); R( 1); R( 2); R( 3);
wolfSSL 13:f67a6c6013ca 463 R( 4); R( 5); R( 6); R( 7);
wolfSSL 13:f67a6c6013ca 464 R( 8); R( 9); R(10); R(11);
wolfSSL 13:f67a6c6013ca 465 R(12); R(13); R(14); R(15);
wolfSSL 13:f67a6c6013ca 466 }
wolfSSL 13:f67a6c6013ca 467 #endif /* USE_SLOW_SHA2 */
wolfSSL 13:f67a6c6013ca 468
wolfSSL 13:f67a6c6013ca 469 /* Add the working vars back into digest */
wolfSSL 13:f67a6c6013ca 470
wolfSSL 13:f67a6c6013ca 471 sha512->digest[0] += a(0);
wolfSSL 13:f67a6c6013ca 472 sha512->digest[1] += b(0);
wolfSSL 13:f67a6c6013ca 473 sha512->digest[2] += c(0);
wolfSSL 13:f67a6c6013ca 474 sha512->digest[3] += d(0);
wolfSSL 13:f67a6c6013ca 475 sha512->digest[4] += e(0);
wolfSSL 13:f67a6c6013ca 476 sha512->digest[5] += f(0);
wolfSSL 13:f67a6c6013ca 477 sha512->digest[6] += g(0);
wolfSSL 13:f67a6c6013ca 478 sha512->digest[7] += h(0);
wolfSSL 13:f67a6c6013ca 479
wolfSSL 13:f67a6c6013ca 480 /* Wipe variables */
wolfSSL 13:f67a6c6013ca 481 ForceZero(W, sizeof(word64) * 16);
wolfSSL 13:f67a6c6013ca 482 ForceZero(T, sizeof(T));
wolfSSL 13:f67a6c6013ca 483
wolfSSL 13:f67a6c6013ca 484 #ifdef WOLFSSL_SMALL_STACK
wolfSSL 13:f67a6c6013ca 485 XFREE(W, NULL, DYNAMIC_TYPE_TMP_BUFFER);
wolfSSL 13:f67a6c6013ca 486 #endif
wolfSSL 13:f67a6c6013ca 487
wolfSSL 13:f67a6c6013ca 488 return 0;
wolfSSL 13:f67a6c6013ca 489 }
wolfSSL 13:f67a6c6013ca 490
wolfSSL 13:f67a6c6013ca 491
wolfSSL 13:f67a6c6013ca 492 static INLINE void AddLength(Sha512* sha512, word32 len)
wolfSSL 13:f67a6c6013ca 493 {
wolfSSL 13:f67a6c6013ca 494 word64 tmp = sha512->loLen;
wolfSSL 13:f67a6c6013ca 495 if ( (sha512->loLen += len) < tmp)
wolfSSL 13:f67a6c6013ca 496 sha512->hiLen++; /* carry low to high */
wolfSSL 13:f67a6c6013ca 497 }
wolfSSL 13:f67a6c6013ca 498
wolfSSL 13:f67a6c6013ca 499 static INLINE int Sha512Update(Sha512* sha512, const byte* data, word32 len)
wolfSSL 13:f67a6c6013ca 500 {
wolfSSL 13:f67a6c6013ca 501 int ret = 0;
wolfSSL 13:f67a6c6013ca 502 /* do block size increments */
wolfSSL 13:f67a6c6013ca 503 byte* local = (byte*)sha512->buffer;
wolfSSL 13:f67a6c6013ca 504
wolfSSL 13:f67a6c6013ca 505 /* check that internal buffLen is valid */
wolfSSL 13:f67a6c6013ca 506 if (sha512->buffLen >= SHA512_BLOCK_SIZE)
wolfSSL 13:f67a6c6013ca 507 return BUFFER_E;
wolfSSL 13:f67a6c6013ca 508
wolfSSL 13:f67a6c6013ca 509 SAVE_XMM_YMM; /* for Intel AVX */
wolfSSL 13:f67a6c6013ca 510
wolfSSL 13:f67a6c6013ca 511 while (len) {
wolfSSL 13:f67a6c6013ca 512 word32 add = min(len, SHA512_BLOCK_SIZE - sha512->buffLen);
wolfSSL 13:f67a6c6013ca 513 XMEMCPY(&local[sha512->buffLen], data, add);
wolfSSL 13:f67a6c6013ca 514
wolfSSL 13:f67a6c6013ca 515 sha512->buffLen += add;
wolfSSL 13:f67a6c6013ca 516 data += add;
wolfSSL 13:f67a6c6013ca 517 len -= add;
wolfSSL 13:f67a6c6013ca 518
wolfSSL 13:f67a6c6013ca 519 if (sha512->buffLen == SHA512_BLOCK_SIZE) {
wolfSSL 13:f67a6c6013ca 520 #if defined(LITTLE_ENDIAN_ORDER)
wolfSSL 13:f67a6c6013ca 521 #if defined(HAVE_INTEL_AVX1) || defined(HAVE_INTEL_AVX2)
wolfSSL 13:f67a6c6013ca 522 if (!IS_INTEL_AVX1(intel_flags) && !IS_INTEL_AVX2(intel_flags))
wolfSSL 13:f67a6c6013ca 523 #endif
wolfSSL 13:f67a6c6013ca 524 {
wolfSSL 13:f67a6c6013ca 525 ByteReverseWords64(sha512->buffer, sha512->buffer,
wolfSSL 13:f67a6c6013ca 526 SHA512_BLOCK_SIZE);
wolfSSL 13:f67a6c6013ca 527 }
wolfSSL 13:f67a6c6013ca 528 #endif
wolfSSL 13:f67a6c6013ca 529 ret = Transform(sha512);
wolfSSL 13:f67a6c6013ca 530 if (ret != 0)
wolfSSL 13:f67a6c6013ca 531 break;
wolfSSL 13:f67a6c6013ca 532
wolfSSL 13:f67a6c6013ca 533 AddLength(sha512, SHA512_BLOCK_SIZE);
wolfSSL 13:f67a6c6013ca 534 sha512->buffLen = 0;
wolfSSL 13:f67a6c6013ca 535 }
wolfSSL 13:f67a6c6013ca 536 }
wolfSSL 13:f67a6c6013ca 537
wolfSSL 13:f67a6c6013ca 538 return ret;
wolfSSL 13:f67a6c6013ca 539 }
wolfSSL 13:f67a6c6013ca 540
wolfSSL 13:f67a6c6013ca 541 int wc_Sha512Update(Sha512* sha512, const byte* data, word32 len)
wolfSSL 13:f67a6c6013ca 542 {
wolfSSL 13:f67a6c6013ca 543 if (sha512 == NULL || (data == NULL && len > 0)) {
wolfSSL 13:f67a6c6013ca 544 return BAD_FUNC_ARG;
wolfSSL 13:f67a6c6013ca 545 }
wolfSSL 13:f67a6c6013ca 546
wolfSSL 13:f67a6c6013ca 547 #if defined(WOLFSSL_ASYNC_CRYPT) && defined(WC_ASYNC_ENABLE_SHA512)
wolfSSL 13:f67a6c6013ca 548 if (sha512->asyncDev.marker == WOLFSSL_ASYNC_MARKER_SHA512) {
wolfSSL 13:f67a6c6013ca 549 #if defined(HAVE_INTEL_QA)
wolfSSL 13:f67a6c6013ca 550 return IntelQaSymSha512(&sha512->asyncDev, NULL, data, len);
wolfSSL 13:f67a6c6013ca 551 #endif
wolfSSL 13:f67a6c6013ca 552 }
wolfSSL 13:f67a6c6013ca 553 #endif /* WOLFSSL_ASYNC_CRYPT */
wolfSSL 13:f67a6c6013ca 554
wolfSSL 13:f67a6c6013ca 555 return Sha512Update(sha512, data, len);
wolfSSL 13:f67a6c6013ca 556 }
wolfSSL 13:f67a6c6013ca 557
wolfSSL 13:f67a6c6013ca 558
wolfSSL 13:f67a6c6013ca 559 static INLINE int Sha512Final(Sha512* sha512)
wolfSSL 13:f67a6c6013ca 560 {
wolfSSL 13:f67a6c6013ca 561 byte* local = (byte*)sha512->buffer;
wolfSSL 13:f67a6c6013ca 562 int ret;
wolfSSL 13:f67a6c6013ca 563
wolfSSL 13:f67a6c6013ca 564 if (sha512 == NULL) {
wolfSSL 13:f67a6c6013ca 565 return BAD_FUNC_ARG;
wolfSSL 13:f67a6c6013ca 566 }
wolfSSL 13:f67a6c6013ca 567
wolfSSL 13:f67a6c6013ca 568 SAVE_XMM_YMM ; /* for Intel AVX */
wolfSSL 13:f67a6c6013ca 569 AddLength(sha512, sha512->buffLen); /* before adding pads */
wolfSSL 13:f67a6c6013ca 570
wolfSSL 13:f67a6c6013ca 571 local[sha512->buffLen++] = 0x80; /* add 1 */
wolfSSL 13:f67a6c6013ca 572
wolfSSL 13:f67a6c6013ca 573 /* pad with zeros */
wolfSSL 13:f67a6c6013ca 574 if (sha512->buffLen > SHA512_PAD_SIZE) {
wolfSSL 13:f67a6c6013ca 575 XMEMSET(&local[sha512->buffLen], 0, SHA512_BLOCK_SIZE - sha512->buffLen);
wolfSSL 13:f67a6c6013ca 576 sha512->buffLen += SHA512_BLOCK_SIZE - sha512->buffLen;
wolfSSL 13:f67a6c6013ca 577 #if defined(LITTLE_ENDIAN_ORDER)
wolfSSL 13:f67a6c6013ca 578 #if defined(HAVE_INTEL_AVX1) || defined(HAVE_INTEL_AVX2)
wolfSSL 13:f67a6c6013ca 579 if (!IS_INTEL_AVX1(intel_flags) && !IS_INTEL_AVX2(intel_flags))
wolfSSL 13:f67a6c6013ca 580 #endif
wolfSSL 13:f67a6c6013ca 581 {
wolfSSL 13:f67a6c6013ca 582 ByteReverseWords64(sha512->buffer,sha512->buffer,
wolfSSL 13:f67a6c6013ca 583 SHA512_BLOCK_SIZE);
wolfSSL 13:f67a6c6013ca 584 }
wolfSSL 13:f67a6c6013ca 585 #endif /* LITTLE_ENDIAN_ORDER */
wolfSSL 13:f67a6c6013ca 586 ret = Transform(sha512);
wolfSSL 13:f67a6c6013ca 587 if (ret != 0)
wolfSSL 13:f67a6c6013ca 588 return ret;
wolfSSL 13:f67a6c6013ca 589
wolfSSL 13:f67a6c6013ca 590 sha512->buffLen = 0;
wolfSSL 13:f67a6c6013ca 591 }
wolfSSL 13:f67a6c6013ca 592 XMEMSET(&local[sha512->buffLen], 0, SHA512_PAD_SIZE - sha512->buffLen);
wolfSSL 13:f67a6c6013ca 593
wolfSSL 13:f67a6c6013ca 594 /* put lengths in bits */
wolfSSL 13:f67a6c6013ca 595 sha512->hiLen = (sha512->loLen >> (8 * sizeof(sha512->loLen) - 3)) +
wolfSSL 13:f67a6c6013ca 596 (sha512->hiLen << 3);
wolfSSL 13:f67a6c6013ca 597 sha512->loLen = sha512->loLen << 3;
wolfSSL 13:f67a6c6013ca 598
wolfSSL 13:f67a6c6013ca 599 /* store lengths */
wolfSSL 13:f67a6c6013ca 600 #if defined(LITTLE_ENDIAN_ORDER)
wolfSSL 13:f67a6c6013ca 601 #if defined(HAVE_INTEL_AVX1) || defined(HAVE_INTEL_AVX2)
wolfSSL 13:f67a6c6013ca 602 if (!IS_INTEL_AVX1(intel_flags) && !IS_INTEL_AVX2(intel_flags))
wolfSSL 13:f67a6c6013ca 603 #endif
wolfSSL 13:f67a6c6013ca 604 ByteReverseWords64(sha512->buffer, sha512->buffer, SHA512_PAD_SIZE);
wolfSSL 13:f67a6c6013ca 605 #endif
wolfSSL 13:f67a6c6013ca 606 /* ! length ordering dependent on digest endian type ! */
wolfSSL 13:f67a6c6013ca 607
wolfSSL 13:f67a6c6013ca 608 sha512->buffer[SHA512_BLOCK_SIZE / sizeof(word64) - 2] = sha512->hiLen;
wolfSSL 13:f67a6c6013ca 609 sha512->buffer[SHA512_BLOCK_SIZE / sizeof(word64) - 1] = sha512->loLen;
wolfSSL 13:f67a6c6013ca 610 #if defined(HAVE_INTEL_AVX1) || defined(HAVE_INTEL_AVX2)
wolfSSL 13:f67a6c6013ca 611 if (IS_INTEL_AVX1(intel_flags) || IS_INTEL_AVX2(intel_flags))
wolfSSL 13:f67a6c6013ca 612 ByteReverseWords64(&(sha512->buffer[SHA512_BLOCK_SIZE / sizeof(word64) - 2]),
wolfSSL 13:f67a6c6013ca 613 &(sha512->buffer[SHA512_BLOCK_SIZE / sizeof(word64) - 2]),
wolfSSL 13:f67a6c6013ca 614 SHA512_BLOCK_SIZE - SHA512_PAD_SIZE);
wolfSSL 13:f67a6c6013ca 615 #endif
wolfSSL 13:f67a6c6013ca 616 ret = Transform(sha512);
wolfSSL 13:f67a6c6013ca 617 if (ret != 0)
wolfSSL 13:f67a6c6013ca 618 return ret;
wolfSSL 13:f67a6c6013ca 619
wolfSSL 13:f67a6c6013ca 620 #ifdef LITTLE_ENDIAN_ORDER
wolfSSL 13:f67a6c6013ca 621 ByteReverseWords64(sha512->digest, sha512->digest, SHA512_DIGEST_SIZE);
wolfSSL 13:f67a6c6013ca 622 #endif
wolfSSL 13:f67a6c6013ca 623
wolfSSL 13:f67a6c6013ca 624 return 0;
wolfSSL 13:f67a6c6013ca 625 }
wolfSSL 13:f67a6c6013ca 626
wolfSSL 13:f67a6c6013ca 627 int wc_Sha512Final(Sha512* sha512, byte* hash)
wolfSSL 13:f67a6c6013ca 628 {
wolfSSL 13:f67a6c6013ca 629 int ret;
wolfSSL 13:f67a6c6013ca 630
wolfSSL 13:f67a6c6013ca 631 if (sha512 == NULL || hash == NULL) {
wolfSSL 13:f67a6c6013ca 632 return BAD_FUNC_ARG;
wolfSSL 13:f67a6c6013ca 633 }
wolfSSL 13:f67a6c6013ca 634
wolfSSL 13:f67a6c6013ca 635 #if defined(WOLFSSL_ASYNC_CRYPT) && defined(WC_ASYNC_ENABLE_SHA512)
wolfSSL 13:f67a6c6013ca 636 if (sha512->asyncDev.marker == WOLFSSL_ASYNC_MARKER_SHA512) {
wolfSSL 13:f67a6c6013ca 637 #if defined(HAVE_INTEL_QA)
wolfSSL 13:f67a6c6013ca 638 return IntelQaSymSha512(&sha512->asyncDev, hash, NULL,
wolfSSL 13:f67a6c6013ca 639 SHA512_DIGEST_SIZE);
wolfSSL 13:f67a6c6013ca 640 #endif
wolfSSL 13:f67a6c6013ca 641 }
wolfSSL 13:f67a6c6013ca 642 #endif /* WOLFSSL_ASYNC_CRYPT */
wolfSSL 13:f67a6c6013ca 643
wolfSSL 13:f67a6c6013ca 644 ret = Sha512Final(sha512);
wolfSSL 13:f67a6c6013ca 645 if (ret != 0)
wolfSSL 13:f67a6c6013ca 646 return ret;
wolfSSL 13:f67a6c6013ca 647
wolfSSL 13:f67a6c6013ca 648 XMEMCPY(hash, sha512->digest, SHA512_DIGEST_SIZE);
wolfSSL 13:f67a6c6013ca 649
wolfSSL 13:f67a6c6013ca 650 return InitSha512(sha512); /* reset state */
wolfSSL 13:f67a6c6013ca 651 }
wolfSSL 13:f67a6c6013ca 652
wolfSSL 13:f67a6c6013ca 653
wolfSSL 13:f67a6c6013ca 654 int wc_InitSha512(Sha512* sha512)
wolfSSL 13:f67a6c6013ca 655 {
wolfSSL 13:f67a6c6013ca 656 return wc_InitSha512_ex(sha512, NULL, INVALID_DEVID);
wolfSSL 13:f67a6c6013ca 657 }
wolfSSL 13:f67a6c6013ca 658
wolfSSL 13:f67a6c6013ca 659 void wc_Sha512Free(Sha512* sha512)
wolfSSL 13:f67a6c6013ca 660 {
wolfSSL 13:f67a6c6013ca 661 if (sha512 == NULL)
wolfSSL 13:f67a6c6013ca 662 return;
wolfSSL 13:f67a6c6013ca 663
wolfSSL 13:f67a6c6013ca 664 #if defined(WOLFSSL_ASYNC_CRYPT) && defined(WC_ASYNC_ENABLE_SHA512)
wolfSSL 13:f67a6c6013ca 665 wolfAsync_DevCtxFree(&sha512->asyncDev, WOLFSSL_ASYNC_MARKER_SHA512);
wolfSSL 13:f67a6c6013ca 666 #endif /* WOLFSSL_ASYNC_CRYPT */
wolfSSL 13:f67a6c6013ca 667 }
wolfSSL 13:f67a6c6013ca 668
wolfSSL 13:f67a6c6013ca 669
wolfSSL 13:f67a6c6013ca 670 #if defined(HAVE_INTEL_AVX1)
wolfSSL 13:f67a6c6013ca 671
wolfSSL 13:f67a6c6013ca 672 #define Rx_1(i) h(i)+=S1(e(i))+Ch(e(i),f(i),g(i))+K[i+j] + W_X[i];
wolfSSL 13:f67a6c6013ca 673 #define Rx_2(i) d(i)+=h(i);
wolfSSL 13:f67a6c6013ca 674 #define Rx_3(i) h(i)+=S0(a(i))+Maj(a(i),b(i),c(i));
wolfSSL 13:f67a6c6013ca 675
wolfSSL 13:f67a6c6013ca 676 #if defined(HAVE_INTEL_RORX)
wolfSSL 13:f67a6c6013ca 677
wolfSSL 13:f67a6c6013ca 678 #define Rx_RORX_1(i) h(i)+=S1_RORX(e(i))+Ch(e(i),f(i),g(i))+K[i+j] + W_X[i];
wolfSSL 13:f67a6c6013ca 679 #define Rx_RORX_2(i) d(i)+=h(i);
wolfSSL 13:f67a6c6013ca 680 #define Rx_RORX_3(i) h(i)+=S0_RORX(a(i))+Maj(a(i),b(i),c(i));
wolfSSL 13:f67a6c6013ca 681 #endif /* HAVE_INTEL_RORX */
wolfSSL 13:f67a6c6013ca 682
wolfSSL 13:f67a6c6013ca 683 #endif /* HAVE_INTEL_AVX1 */
wolfSSL 13:f67a6c6013ca 684
wolfSSL 13:f67a6c6013ca 685 #if defined(HAVE_INTEL_AVX2)
wolfSSL 13:f67a6c6013ca 686 #define Ry_1(i, w) h(i)+=S1(e(i))+Ch(e(i),f(i),g(i))+K[i+j] + w;
wolfSSL 13:f67a6c6013ca 687 #define Ry_2(i, w) d(i)+=h(i);
wolfSSL 13:f67a6c6013ca 688 #define Ry_3(i, w) h(i)+=S0(a(i))+Maj(a(i),b(i),c(i));
wolfSSL 13:f67a6c6013ca 689 #endif /* HAVE_INTEL_AVX2 */
wolfSSL 13:f67a6c6013ca 690
wolfSSL 13:f67a6c6013ca 691 /* INLINE Assember for Intel AVX1 instructions */
wolfSSL 13:f67a6c6013ca 692 #if defined(HAVE_INTEL_AVX1)
wolfSSL 13:f67a6c6013ca 693 #if defined(DEBUG_XMM)
wolfSSL 13:f67a6c6013ca 694 #define SAVE_REG(i) __asm__ volatile("vmovdqu %%xmm"#i", %0 \n\t":"=m"(reg[i][0])::XMM_REGs);
wolfSSL 13:f67a6c6013ca 695 #define RECV_REG(i) __asm__ volatile("vmovdqu %0, %%xmm"#i" \n\t"::"m"(reg[i][0]):XMM_REGs);
wolfSSL 13:f67a6c6013ca 696
wolfSSL 13:f67a6c6013ca 697 #define _DUMP_REG(REG, name)\
wolfSSL 13:f67a6c6013ca 698 { word64 buf[16];word64 reg[16][2];int k;\
wolfSSL 13:f67a6c6013ca 699 SAVE_REG(0); SAVE_REG(1); SAVE_REG(2); SAVE_REG(3); SAVE_REG(4); \
wolfSSL 13:f67a6c6013ca 700 SAVE_REG(5); SAVE_REG(6); SAVE_REG(7);SAVE_REG(8); SAVE_REG(9); SAVE_REG(10);\
wolfSSL 13:f67a6c6013ca 701 SAVE_REG(11); SAVE_REG(12); SAVE_REG(13); SAVE_REG(14); SAVE_REG(15); \
wolfSSL 13:f67a6c6013ca 702 __asm__ volatile("vmovdqu %%"#REG", %0 \n\t":"=m"(buf[0])::XMM_REGs);\
wolfSSL 13:f67a6c6013ca 703 printf(" "#name":\t"); for(k=0; k<2; k++) printf("%016lx.", (word64)(buf[k])); printf("\n"); \
wolfSSL 13:f67a6c6013ca 704 RECV_REG(0); RECV_REG(1); RECV_REG(2); RECV_REG(3); RECV_REG(4);\
wolfSSL 13:f67a6c6013ca 705 RECV_REG(5); RECV_REG(6); RECV_REG(7); RECV_REG(8); RECV_REG(9);\
wolfSSL 13:f67a6c6013ca 706 RECV_REG(10); RECV_REG(11); RECV_REG(12); RECV_REG(13); RECV_REG(14); RECV_REG(15);\
wolfSSL 13:f67a6c6013ca 707 }
wolfSSL 13:f67a6c6013ca 708
wolfSSL 13:f67a6c6013ca 709 #define DUMP_REG(REG) _DUMP_REG(REG, #REG)
wolfSSL 13:f67a6c6013ca 710 #define PRINTF(fmt, ...)
wolfSSL 13:f67a6c6013ca 711 #else
wolfSSL 13:f67a6c6013ca 712 #define DUMP_REG(REG)
wolfSSL 13:f67a6c6013ca 713 #define PRINTF(fmt, ...)
wolfSSL 13:f67a6c6013ca 714 #endif /* DEBUG_XMM */
wolfSSL 13:f67a6c6013ca 715
wolfSSL 13:f67a6c6013ca 716 #define _MOVE_to_REG(xymm, mem) __asm__ volatile("vmovdqu %0, %%"#xymm" "\
wolfSSL 13:f67a6c6013ca 717 :: "m"(mem):XMM_REGs);
wolfSSL 13:f67a6c6013ca 718 #define _MOVE_to_MEM(mem,i, xymm) __asm__ volatile("vmovdqu %%"#xymm", %0" :\
wolfSSL 13:f67a6c6013ca 719 "=m"(mem[i]),"=m"(mem[i+1]),"=m"(mem[i+2]),"=m"(mem[i+3])::XMM_REGs);
wolfSSL 13:f67a6c6013ca 720 #define _MOVE(dest, src) __asm__ volatile("vmovdqu %%"#src", %%"\
wolfSSL 13:f67a6c6013ca 721 #dest" ":::XMM_REGs);
wolfSSL 13:f67a6c6013ca 722
wolfSSL 13:f67a6c6013ca 723 #define _S_TEMP(dest, src, bits, temp) __asm__ volatile("vpsrlq $"#bits", %%"\
wolfSSL 13:f67a6c6013ca 724 #src", %%"#dest"\n\tvpsllq $64-"#bits", %%"#src", %%"#temp"\n\tvpor %%"\
wolfSSL 13:f67a6c6013ca 725 #temp",%%"#dest", %%"#dest" ":::XMM_REGs);
wolfSSL 13:f67a6c6013ca 726 #define _AVX1_R(dest, src, bits) __asm__ volatile("vpsrlq $"#bits", %%"\
wolfSSL 13:f67a6c6013ca 727 #src", %%"#dest" ":::XMM_REGs);
wolfSSL 13:f67a6c6013ca 728 #define _XOR(dest, src1, src2) __asm__ volatile("vpxor %%"#src1", %%"\
wolfSSL 13:f67a6c6013ca 729 #src2", %%"#dest" ":::XMM_REGs);
wolfSSL 13:f67a6c6013ca 730 #define _OR(dest, src1, src2) __asm__ volatile("vpor %%"#src1", %%"\
wolfSSL 13:f67a6c6013ca 731 #src2", %%"#dest" ":::XMM_REGs);
wolfSSL 13:f67a6c6013ca 732 #define _ADD(dest, src1, src2) __asm__ volatile("vpaddq %%"#src1", %%"\
wolfSSL 13:f67a6c6013ca 733 #src2", %%"#dest" ":::XMM_REGs);
wolfSSL 13:f67a6c6013ca 734 #define _ADD_MEM(dest, src1, mem) __asm__ volatile("vpaddq %0, %%"#src1", %%"\
wolfSSL 13:f67a6c6013ca 735 #dest" "::"m"(mem):XMM_REGs);
wolfSSL 13:f67a6c6013ca 736
wolfSSL 13:f67a6c6013ca 737 #define MOVE_to_REG(xymm, mem) _MOVE_to_REG(xymm, mem)
wolfSSL 13:f67a6c6013ca 738 #define MOVE_to_MEM(mem, i, xymm) _MOVE_to_MEM(mem, i, xymm)
wolfSSL 13:f67a6c6013ca 739 #define MOVE(dest, src) _MOVE(dest, src)
wolfSSL 13:f67a6c6013ca 740
wolfSSL 13:f67a6c6013ca 741 #define XOR(dest, src1, src2) _XOR(dest, src1, src2)
wolfSSL 13:f67a6c6013ca 742 #define OR(dest, src1, src2) _OR(dest, src1, src2)
wolfSSL 13:f67a6c6013ca 743 #define ADD(dest, src1, src2) _ADD(dest, src1, src2)
wolfSSL 13:f67a6c6013ca 744
wolfSSL 13:f67a6c6013ca 745 #define S_TMP(dest, src, bits, temp) _S_TEMP(dest, src, bits, temp);
wolfSSL 13:f67a6c6013ca 746 #define AVX1_S(dest, src, bits) S_TMP(dest, src, bits, S_TEMP)
wolfSSL 13:f67a6c6013ca 747 #define AVX1_R(dest, src, bits) _AVX1_R(dest, src, bits)
wolfSSL 13:f67a6c6013ca 748
wolfSSL 13:f67a6c6013ca 749 #define Init_Mask(mask) \
wolfSSL 13:f67a6c6013ca 750 __asm__ volatile("vmovdqu %0, %%xmm1\n\t"::"m"(mask):"%xmm1");
wolfSSL 13:f67a6c6013ca 751
wolfSSL 13:f67a6c6013ca 752 #define _W_from_buff1(w, buff, xmm) \
wolfSSL 13:f67a6c6013ca 753 /* X0..3(xmm4..7), W[0..15] = sha512->buffer[0.15]; */\
wolfSSL 13:f67a6c6013ca 754 __asm__ volatile("vmovdqu %1, %%"#xmm"\n\t"\
wolfSSL 13:f67a6c6013ca 755 "vpshufb %%xmm1, %%"#xmm", %%"#xmm"\n\t"\
wolfSSL 13:f67a6c6013ca 756 "vmovdqu %%"#xmm", %0"\
wolfSSL 13:f67a6c6013ca 757 :"=m"(w): "m"(buff):"%xmm0");
wolfSSL 13:f67a6c6013ca 758
wolfSSL 13:f67a6c6013ca 759 #define W_from_buff1(w, buff, xmm) _W_from_buff1(w, buff, xmm)
wolfSSL 13:f67a6c6013ca 760
wolfSSL 13:f67a6c6013ca 761 #define W_from_buff(w, buff)\
wolfSSL 13:f67a6c6013ca 762 Init_Mask(mBYTE_FLIP_MASK[0]);\
wolfSSL 13:f67a6c6013ca 763 W_from_buff1(w[0], buff[0], W_0);\
wolfSSL 13:f67a6c6013ca 764 W_from_buff1(w[2], buff[2], W_2);\
wolfSSL 13:f67a6c6013ca 765 W_from_buff1(w[4], buff[4], W_4);\
wolfSSL 13:f67a6c6013ca 766 W_from_buff1(w[6], buff[6], W_6);\
wolfSSL 13:f67a6c6013ca 767 W_from_buff1(w[8], buff[8], W_8);\
wolfSSL 13:f67a6c6013ca 768 W_from_buff1(w[10],buff[10],W_10);\
wolfSSL 13:f67a6c6013ca 769 W_from_buff1(w[12],buff[12],W_12);\
wolfSSL 13:f67a6c6013ca 770 W_from_buff1(w[14],buff[14],W_14);
wolfSSL 13:f67a6c6013ca 771
wolfSSL 13:f67a6c6013ca 772 static word64 mBYTE_FLIP_MASK[] = { 0x0001020304050607, 0x08090a0b0c0d0e0f };
wolfSSL 13:f67a6c6013ca 773
wolfSSL 13:f67a6c6013ca 774 #define W_I_15 xmm14
wolfSSL 13:f67a6c6013ca 775 #define W_I_7 xmm11
wolfSSL 13:f67a6c6013ca 776 #define W_I_2 xmm13
wolfSSL 13:f67a6c6013ca 777 #define W_I xmm12
wolfSSL 13:f67a6c6013ca 778 #define G_TEMP xmm0
wolfSSL 13:f67a6c6013ca 779 #define S_TEMP xmm1
wolfSSL 13:f67a6c6013ca 780 #define XMM_TEMP0 xmm2
wolfSSL 13:f67a6c6013ca 781
wolfSSL 13:f67a6c6013ca 782 #define W_0 xmm12
wolfSSL 13:f67a6c6013ca 783 #define W_2 xmm3
wolfSSL 13:f67a6c6013ca 784 #define W_4 xmm4
wolfSSL 13:f67a6c6013ca 785 #define W_6 xmm5
wolfSSL 13:f67a6c6013ca 786 #define W_8 xmm6
wolfSSL 13:f67a6c6013ca 787 #define W_10 xmm7
wolfSSL 13:f67a6c6013ca 788 #define W_12 xmm8
wolfSSL 13:f67a6c6013ca 789 #define W_14 xmm9
wolfSSL 13:f67a6c6013ca 790
wolfSSL 13:f67a6c6013ca 791 #define XMM_REGs
wolfSSL 13:f67a6c6013ca 792
wolfSSL 13:f67a6c6013ca 793 #define s0_1(dest, src) AVX1_S(dest, src, 1);
wolfSSL 13:f67a6c6013ca 794 #define s0_2(dest, src) AVX1_S(G_TEMP, src, 8); XOR(dest, G_TEMP, dest);
wolfSSL 13:f67a6c6013ca 795 #define s0_3(dest, src) AVX1_R(G_TEMP, src, 7); XOR(dest, G_TEMP, dest);
wolfSSL 13:f67a6c6013ca 796
wolfSSL 13:f67a6c6013ca 797 #define s1_1(dest, src) AVX1_S(dest, src, 19);
wolfSSL 13:f67a6c6013ca 798 #define s1_2(dest, src) AVX1_S(G_TEMP, src, 61); XOR(dest, G_TEMP, dest);
wolfSSL 13:f67a6c6013ca 799 #define s1_3(dest, src) AVX1_R(G_TEMP, src, 6); XOR(dest, G_TEMP, dest);
wolfSSL 13:f67a6c6013ca 800
wolfSSL 13:f67a6c6013ca 801 #define s0_(dest, src) s0_1(dest, src); s0_2(dest, src); s0_3(dest, src)
wolfSSL 13:f67a6c6013ca 802 #define s1_(dest, src) s1_1(dest, src); s1_2(dest, src); s1_3(dest, src)
wolfSSL 13:f67a6c6013ca 803
wolfSSL 13:f67a6c6013ca 804 #define Block_xx_1(i) \
wolfSSL 13:f67a6c6013ca 805 MOVE_to_REG(W_I_15, W_X[(i-15)&15]);\
wolfSSL 13:f67a6c6013ca 806 MOVE_to_REG(W_I_7, W_X[(i- 7)&15]);\
wolfSSL 13:f67a6c6013ca 807
wolfSSL 13:f67a6c6013ca 808 #define Block_xx_2(i) \
wolfSSL 13:f67a6c6013ca 809 MOVE_to_REG(W_I_2, W_X[(i- 2)&15]);\
wolfSSL 13:f67a6c6013ca 810 MOVE_to_REG(W_I, W_X[(i)]);\
wolfSSL 13:f67a6c6013ca 811
wolfSSL 13:f67a6c6013ca 812 #define Block_xx_3(i) \
wolfSSL 13:f67a6c6013ca 813 s0_ (XMM_TEMP0, W_I_15);\
wolfSSL 13:f67a6c6013ca 814
wolfSSL 13:f67a6c6013ca 815 #define Block_xx_4(i) \
wolfSSL 13:f67a6c6013ca 816 ADD(W_I, W_I, XMM_TEMP0);\
wolfSSL 13:f67a6c6013ca 817 ADD(W_I, W_I, W_I_7);\
wolfSSL 13:f67a6c6013ca 818
wolfSSL 13:f67a6c6013ca 819 #define Block_xx_5(i) \
wolfSSL 13:f67a6c6013ca 820 s1_ (XMM_TEMP0, W_I_2);\
wolfSSL 13:f67a6c6013ca 821
wolfSSL 13:f67a6c6013ca 822 #define Block_xx_6(i) \
wolfSSL 13:f67a6c6013ca 823 ADD(W_I, W_I, XMM_TEMP0);\
wolfSSL 13:f67a6c6013ca 824 MOVE_to_MEM(W_X,i, W_I);\
wolfSSL 13:f67a6c6013ca 825 if (i==0)\
wolfSSL 13:f67a6c6013ca 826 MOVE_to_MEM(W_X,16, W_I);\
wolfSSL 13:f67a6c6013ca 827
wolfSSL 13:f67a6c6013ca 828 #define Block_xx_7(i) \
wolfSSL 13:f67a6c6013ca 829 MOVE_to_REG(W_I_15, W_X[(i-15)&15]);\
wolfSSL 13:f67a6c6013ca 830 MOVE_to_REG(W_I_7, W_X[(i- 7)&15]);\
wolfSSL 13:f67a6c6013ca 831
wolfSSL 13:f67a6c6013ca 832 #define Block_xx_8(i) \
wolfSSL 13:f67a6c6013ca 833 MOVE_to_REG(W_I_2, W_X[(i- 2)&15]);\
wolfSSL 13:f67a6c6013ca 834 MOVE_to_REG(W_I, W_X[(i)]);\
wolfSSL 13:f67a6c6013ca 835
wolfSSL 13:f67a6c6013ca 836 #define Block_xx_9(i) \
wolfSSL 13:f67a6c6013ca 837 s0_ (XMM_TEMP0, W_I_15);\
wolfSSL 13:f67a6c6013ca 838
wolfSSL 13:f67a6c6013ca 839 #define Block_xx_10(i) \
wolfSSL 13:f67a6c6013ca 840 ADD(W_I, W_I, XMM_TEMP0);\
wolfSSL 13:f67a6c6013ca 841 ADD(W_I, W_I, W_I_7);\
wolfSSL 13:f67a6c6013ca 842
wolfSSL 13:f67a6c6013ca 843 #define Block_xx_11(i) \
wolfSSL 13:f67a6c6013ca 844 s1_ (XMM_TEMP0, W_I_2);\
wolfSSL 13:f67a6c6013ca 845
wolfSSL 13:f67a6c6013ca 846 #define Block_xx_12(i) \
wolfSSL 13:f67a6c6013ca 847 ADD(W_I, W_I, XMM_TEMP0);\
wolfSSL 13:f67a6c6013ca 848 MOVE_to_MEM(W_X,i, W_I);\
wolfSSL 13:f67a6c6013ca 849 if ((i)==0)\
wolfSSL 13:f67a6c6013ca 850 MOVE_to_MEM(W_X,16, W_I);\
wolfSSL 13:f67a6c6013ca 851
wolfSSL 13:f67a6c6013ca 852 static INLINE void Block_0_1(word64 *W_X) { Block_xx_1(0); }
wolfSSL 13:f67a6c6013ca 853 static INLINE void Block_0_2(word64 *W_X) { Block_xx_2(0); }
wolfSSL 13:f67a6c6013ca 854 static INLINE void Block_0_3(void) { Block_xx_3(0); }
wolfSSL 13:f67a6c6013ca 855 static INLINE void Block_0_4(void) { Block_xx_4(0); }
wolfSSL 13:f67a6c6013ca 856 static INLINE void Block_0_5(void) { Block_xx_5(0); }
wolfSSL 13:f67a6c6013ca 857 static INLINE void Block_0_6(word64 *W_X) { Block_xx_6(0); }
wolfSSL 13:f67a6c6013ca 858 static INLINE void Block_0_7(word64 *W_X) { Block_xx_7(2); }
wolfSSL 13:f67a6c6013ca 859 static INLINE void Block_0_8(word64 *W_X) { Block_xx_8(2); }
wolfSSL 13:f67a6c6013ca 860 static INLINE void Block_0_9(void) { Block_xx_9(2); }
wolfSSL 13:f67a6c6013ca 861 static INLINE void Block_0_10(void){ Block_xx_10(2); }
wolfSSL 13:f67a6c6013ca 862 static INLINE void Block_0_11(void){ Block_xx_11(2); }
wolfSSL 13:f67a6c6013ca 863 static INLINE void Block_0_12(word64 *W_X){ Block_xx_12(2); }
wolfSSL 13:f67a6c6013ca 864
wolfSSL 13:f67a6c6013ca 865 static INLINE void Block_4_1(word64 *W_X) { Block_xx_1(4); }
wolfSSL 13:f67a6c6013ca 866 static INLINE void Block_4_2(word64 *W_X) { Block_xx_2(4); }
wolfSSL 13:f67a6c6013ca 867 static INLINE void Block_4_3(void) { Block_xx_3(4); }
wolfSSL 13:f67a6c6013ca 868 static INLINE void Block_4_4(void) { Block_xx_4(4); }
wolfSSL 13:f67a6c6013ca 869 static INLINE void Block_4_5(void) { Block_xx_5(4); }
wolfSSL 13:f67a6c6013ca 870 static INLINE void Block_4_6(word64 *W_X) { Block_xx_6(4); }
wolfSSL 13:f67a6c6013ca 871 static INLINE void Block_4_7(word64 *W_X) { Block_xx_7(6); }
wolfSSL 13:f67a6c6013ca 872 static INLINE void Block_4_8(word64 *W_X) { Block_xx_8(6); }
wolfSSL 13:f67a6c6013ca 873 static INLINE void Block_4_9(void) { Block_xx_9(6); }
wolfSSL 13:f67a6c6013ca 874 static INLINE void Block_4_10(void){ Block_xx_10(6); }
wolfSSL 13:f67a6c6013ca 875 static INLINE void Block_4_11(void){ Block_xx_11(6); }
wolfSSL 13:f67a6c6013ca 876 static INLINE void Block_4_12(word64 *W_X){ Block_xx_12(6); }
wolfSSL 13:f67a6c6013ca 877
wolfSSL 13:f67a6c6013ca 878 static INLINE void Block_8_1(word64 *W_X) { Block_xx_1(8); }
wolfSSL 13:f67a6c6013ca 879 static INLINE void Block_8_2(word64 *W_X) { Block_xx_2(8); }
wolfSSL 13:f67a6c6013ca 880 static INLINE void Block_8_3(void) { Block_xx_3(8); }
wolfSSL 13:f67a6c6013ca 881 static INLINE void Block_8_4(void) { Block_xx_4(8); }
wolfSSL 13:f67a6c6013ca 882 static INLINE void Block_8_5(void) { Block_xx_5(8); }
wolfSSL 13:f67a6c6013ca 883 static INLINE void Block_8_6(word64 *W_X) { Block_xx_6(8); }
wolfSSL 13:f67a6c6013ca 884 static INLINE void Block_8_7(word64 *W_X) { Block_xx_7(10); }
wolfSSL 13:f67a6c6013ca 885 static INLINE void Block_8_8(word64 *W_X) { Block_xx_8(10); }
wolfSSL 13:f67a6c6013ca 886 static INLINE void Block_8_9(void) { Block_xx_9(10); }
wolfSSL 13:f67a6c6013ca 887 static INLINE void Block_8_10(void){ Block_xx_10(10); }
wolfSSL 13:f67a6c6013ca 888 static INLINE void Block_8_11(void){ Block_xx_11(10); }
wolfSSL 13:f67a6c6013ca 889 static INLINE void Block_8_12(word64 *W_X){ Block_xx_12(10); }
wolfSSL 13:f67a6c6013ca 890
wolfSSL 13:f67a6c6013ca 891 static INLINE void Block_12_1(word64 *W_X) { Block_xx_1(12); }
wolfSSL 13:f67a6c6013ca 892 static INLINE void Block_12_2(word64 *W_X) { Block_xx_2(12); }
wolfSSL 13:f67a6c6013ca 893 static INLINE void Block_12_3(void) { Block_xx_3(12); }
wolfSSL 13:f67a6c6013ca 894 static INLINE void Block_12_4(void) { Block_xx_4(12); }
wolfSSL 13:f67a6c6013ca 895 static INLINE void Block_12_5(void) { Block_xx_5(12); }
wolfSSL 13:f67a6c6013ca 896 static INLINE void Block_12_6(word64 *W_X) { Block_xx_6(12); }
wolfSSL 13:f67a6c6013ca 897 static INLINE void Block_12_7(word64 *W_X) { Block_xx_7(14); }
wolfSSL 13:f67a6c6013ca 898 static INLINE void Block_12_8(word64 *W_X) { Block_xx_8(14); }
wolfSSL 13:f67a6c6013ca 899 static INLINE void Block_12_9(void) { Block_xx_9(14); }
wolfSSL 13:f67a6c6013ca 900 static INLINE void Block_12_10(void){ Block_xx_10(14); }
wolfSSL 13:f67a6c6013ca 901 static INLINE void Block_12_11(void){ Block_xx_11(14); }
wolfSSL 13:f67a6c6013ca 902 static INLINE void Block_12_12(word64 *W_X){ Block_xx_12(14); }
wolfSSL 13:f67a6c6013ca 903
wolfSSL 13:f67a6c6013ca 904 #endif /* HAVE_INTEL_AVX1 */
wolfSSL 13:f67a6c6013ca 905
wolfSSL 13:f67a6c6013ca 906 #if defined(HAVE_INTEL_AVX2)
wolfSSL 13:f67a6c6013ca 907 static const unsigned long mBYTE_FLIP_MASK_Y[] =
wolfSSL 13:f67a6c6013ca 908 { 0x0001020304050607, 0x08090a0b0c0d0e0f, 0x0001020304050607, 0x08090a0b0c0d0e0f };
wolfSSL 13:f67a6c6013ca 909
wolfSSL 13:f67a6c6013ca 910 #define W_from_buff_Y(buff)\
wolfSSL 13:f67a6c6013ca 911 { /* X0..3(ymm9..12), W_X[0..15] = sha512->buffer[0.15]; */\
wolfSSL 13:f67a6c6013ca 912 __asm__ volatile("vmovdqu %0, %%ymm8\n\t"::"m"(mBYTE_FLIP_MASK_Y[0]):YMM_REGs);\
wolfSSL 13:f67a6c6013ca 913 __asm__ volatile("vmovdqu %0, %%ymm12\n\t"\
wolfSSL 13:f67a6c6013ca 914 "vmovdqu %1, %%ymm4\n\t"\
wolfSSL 13:f67a6c6013ca 915 "vpshufb %%ymm8, %%ymm12, %%ymm12\n\t"\
wolfSSL 13:f67a6c6013ca 916 "vpshufb %%ymm8, %%ymm4, %%ymm4\n\t"\
wolfSSL 13:f67a6c6013ca 917 :: "m"(buff[0]), "m"(buff[4]):YMM_REGs);\
wolfSSL 13:f67a6c6013ca 918 __asm__ volatile("vmovdqu %0, %%ymm5\n\t"\
wolfSSL 13:f67a6c6013ca 919 "vmovdqu %1, %%ymm6\n\t"\
wolfSSL 13:f67a6c6013ca 920 "vpshufb %%ymm8, %%ymm5, %%ymm5\n\t"\
wolfSSL 13:f67a6c6013ca 921 "vpshufb %%ymm8, %%ymm6, %%ymm6\n\t"\
wolfSSL 13:f67a6c6013ca 922 :: "m"(buff[8]), "m"(buff[12]):YMM_REGs);\
wolfSSL 13:f67a6c6013ca 923 }
wolfSSL 13:f67a6c6013ca 924
wolfSSL 13:f67a6c6013ca 925 #if defined(DEBUG_YMM)
wolfSSL 13:f67a6c6013ca 926 #define SAVE_REG_Y(i) __asm__ volatile("vmovdqu %%ymm"#i", %0 \n\t":"=m"(reg[i-4][0])::YMM_REGs);
wolfSSL 13:f67a6c6013ca 927 #define RECV_REG_Y(i) __asm__ volatile("vmovdqu %0, %%ymm"#i" \n\t"::"m"(reg[i-4][0]):YMM_REGs);
wolfSSL 13:f67a6c6013ca 928
wolfSSL 13:f67a6c6013ca 929 #define _DUMP_REG_Y(REG, name)\
wolfSSL 13:f67a6c6013ca 930 { word64 buf[16];word64 reg[16][2];int k;\
wolfSSL 13:f67a6c6013ca 931 SAVE_REG_Y(4); SAVE_REG_Y(5); SAVE_REG_Y(6); SAVE_REG_Y(7); \
wolfSSL 13:f67a6c6013ca 932 SAVE_REG_Y(8); SAVE_REG_Y(9); SAVE_REG_Y(10); SAVE_REG_Y(11); SAVE_REG_Y(12);\
wolfSSL 13:f67a6c6013ca 933 SAVE_REG_Y(13); SAVE_REG_Y(14); SAVE_REG_Y(15); \
wolfSSL 13:f67a6c6013ca 934 __asm__ volatile("vmovdqu %%"#REG", %0 \n\t":"=m"(buf[0])::YMM_REGs);\
wolfSSL 13:f67a6c6013ca 935 printf(" "#name":\t"); for(k=0; k<4; k++) printf("%016lx.", (word64)buf[k]); printf("\n"); \
wolfSSL 13:f67a6c6013ca 936 RECV_REG_Y(4); RECV_REG_Y(5); RECV_REG_Y(6); RECV_REG_Y(7); \
wolfSSL 13:f67a6c6013ca 937 RECV_REG_Y(8); RECV_REG_Y(9); RECV_REG_Y(10); RECV_REG_Y(11); RECV_REG_Y(12); \
wolfSSL 13:f67a6c6013ca 938 RECV_REG_Y(13); RECV_REG_Y(14); RECV_REG_Y(15);\
wolfSSL 13:f67a6c6013ca 939 }
wolfSSL 13:f67a6c6013ca 940
wolfSSL 13:f67a6c6013ca 941 #define DUMP_REG_Y(REG) _DUMP_REG_Y(REG, #REG)
wolfSSL 13:f67a6c6013ca 942 #define DUMP_REG2_Y(REG) _DUMP_REG_Y(REG, #REG)
wolfSSL 13:f67a6c6013ca 943 #define PRINTF_Y(fmt, ...)
wolfSSL 13:f67a6c6013ca 944 #else
wolfSSL 13:f67a6c6013ca 945 #define DUMP_REG_Y(REG)
wolfSSL 13:f67a6c6013ca 946 #define DUMP_REG2_Y(REG)
wolfSSL 13:f67a6c6013ca 947 #define PRINTF_Y(fmt, ...)
wolfSSL 13:f67a6c6013ca 948 #endif /* DEBUG_YMM */
wolfSSL 13:f67a6c6013ca 949
wolfSSL 13:f67a6c6013ca 950 #define _MOVE_to_REGy(ymm, mem) __asm__ volatile("vmovdqu %0, %%"#ymm" "\
wolfSSL 13:f67a6c6013ca 951 :: "m"(mem):YMM_REGs);
wolfSSL 13:f67a6c6013ca 952 #define _MOVE_to_MEMy(mem,i, ymm) __asm__ volatile("vmovdqu %%"#ymm", %0" \
wolfSSL 13:f67a6c6013ca 953 : "=m"(mem[i]),"=m"(mem[i+1]),"=m"(mem[i+2]),"=m"(mem[i+3])::YMM_REGs);
wolfSSL 13:f67a6c6013ca 954 #define _MOVE_128y(ymm0, ymm1, ymm2, map) __asm__ volatile("vperm2i128 $"\
wolfSSL 13:f67a6c6013ca 955 #map", %%"#ymm2", %%"#ymm1", %%"#ymm0" ":::YMM_REGs);
wolfSSL 13:f67a6c6013ca 956 #define _S_TEMPy(dest, src, bits, temp) \
wolfSSL 13:f67a6c6013ca 957 __asm__ volatile("vpsrlq $"#bits", %%"#src", %%"#dest"\n\tvpsllq $64-"#bits\
wolfSSL 13:f67a6c6013ca 958 ", %%"#src", %%"#temp"\n\tvpor %%"#temp",%%"#dest", %%"#dest" ":::YMM_REGs);
wolfSSL 13:f67a6c6013ca 959 #define _AVX2_R(dest, src, bits) __asm__ volatile("vpsrlq $"#bits", %%"\
wolfSSL 13:f67a6c6013ca 960 #src", %%"#dest" ":::YMM_REGs);
wolfSSL 13:f67a6c6013ca 961 #define _XORy(dest, src1, src2) __asm__ volatile("vpxor %%"#src1", %%"\
wolfSSL 13:f67a6c6013ca 962 #src2", %%"#dest" ":::YMM_REGs);
wolfSSL 13:f67a6c6013ca 963 #define _ADDy(dest, src1, src2) __asm__ volatile("vpaddq %%"#src1", %%"\
wolfSSL 13:f67a6c6013ca 964 #src2", %%"#dest" ":::YMM_REGs);
wolfSSL 13:f67a6c6013ca 965 #define _BLENDy(map, dest, src1, src2) __asm__ volatile("vpblendd $"#map", %%"\
wolfSSL 13:f67a6c6013ca 966 #src1", %%"#src2", %%"#dest" ":::YMM_REGs);
wolfSSL 13:f67a6c6013ca 967 #define _BLENDQy(map, dest, src1, src2) __asm__ volatile("vblendpd $"#map", %%"\
wolfSSL 13:f67a6c6013ca 968 #src1", %%"#src2", %%"#dest" ":::YMM_REGs);
wolfSSL 13:f67a6c6013ca 969 #define _PERMQy(map, dest, src) __asm__ volatile("vpermq $"#map", %%"\
wolfSSL 13:f67a6c6013ca 970 #src", %%"#dest" ":::YMM_REGs);
wolfSSL 13:f67a6c6013ca 971
wolfSSL 13:f67a6c6013ca 972 #define MOVE_to_REGy(ymm, mem) _MOVE_to_REGy(ymm, mem)
wolfSSL 13:f67a6c6013ca 973 #define MOVE_to_MEMy(mem, i, ymm) _MOVE_to_MEMy(mem, i, ymm)
wolfSSL 13:f67a6c6013ca 974
wolfSSL 13:f67a6c6013ca 975 #define MOVE_128y(ymm0, ymm1, ymm2, map) _MOVE_128y(ymm0, ymm1, ymm2, map)
wolfSSL 13:f67a6c6013ca 976 #define XORy(dest, src1, src2) _XORy(dest, src1, src2)
wolfSSL 13:f67a6c6013ca 977 #define ADDy(dest, src1, src2) _ADDy(dest, src1, src2)
wolfSSL 13:f67a6c6013ca 978 #define BLENDy(map, dest, src1, src2) _BLENDy(map, dest, src1, src2)
wolfSSL 13:f67a6c6013ca 979 #define BLENDQy(map, dest, src1, src2) _BLENDQy(map, dest, src1, src2)
wolfSSL 13:f67a6c6013ca 980 #define PERMQy(map, dest, src) _PERMQy(map, dest, src)
wolfSSL 13:f67a6c6013ca 981
wolfSSL 13:f67a6c6013ca 982
wolfSSL 13:f67a6c6013ca 983 #define S_TMPy(dest, src, bits, temp) _S_TEMPy(dest, src, bits, temp);
wolfSSL 13:f67a6c6013ca 984 #define AVX2_S(dest, src, bits) S_TMPy(dest, src, bits, S_TEMPy)
wolfSSL 13:f67a6c6013ca 985 #define AVX2_R(dest, src, bits) _AVX2_R(dest, src, bits)
wolfSSL 13:f67a6c6013ca 986
wolfSSL 13:f67a6c6013ca 987
wolfSSL 13:f67a6c6013ca 988 #define FEEDBACK1_to_W_I_2(w_i_2, w_i) MOVE_128y(YMM_TEMP0, w_i, w_i, 0x08);\
wolfSSL 13:f67a6c6013ca 989 BLENDy(0xf0, w_i_2, YMM_TEMP0, w_i_2);
wolfSSL 13:f67a6c6013ca 990
wolfSSL 13:f67a6c6013ca 991 #define MOVE_W_to_W_I_15(w_i_15, w_0, w_4) BLENDQy(0x1, w_i_15, w_4, w_0);\
wolfSSL 13:f67a6c6013ca 992 PERMQy(0x39, w_i_15, w_i_15);
wolfSSL 13:f67a6c6013ca 993 #define MOVE_W_to_W_I_7(w_i_7, w_8, w_12) BLENDQy(0x1, w_i_7, w_12, w_8);\
wolfSSL 13:f67a6c6013ca 994 PERMQy(0x39, w_i_7, w_i_7);
wolfSSL 13:f67a6c6013ca 995 #define MOVE_W_to_W_I_2(w_i_2, w_12) BLENDQy(0xc, w_i_2, w_12, w_i_2);\
wolfSSL 13:f67a6c6013ca 996 PERMQy(0x0e, w_i_2, w_i_2);
wolfSSL 13:f67a6c6013ca 997
wolfSSL 13:f67a6c6013ca 998
wolfSSL 13:f67a6c6013ca 999 #define W_I_16y ymm8
wolfSSL 13:f67a6c6013ca 1000 #define W_I_15y ymm9
wolfSSL 13:f67a6c6013ca 1001 #define W_I_7y ymm10
wolfSSL 13:f67a6c6013ca 1002 #define W_I_2y ymm11
wolfSSL 13:f67a6c6013ca 1003 #define W_Iy ymm12
wolfSSL 13:f67a6c6013ca 1004 #define G_TEMPy ymm13
wolfSSL 13:f67a6c6013ca 1005 #define S_TEMPy ymm14
wolfSSL 13:f67a6c6013ca 1006 #define YMM_TEMP0 ymm15
wolfSSL 13:f67a6c6013ca 1007 #define YMM_TEMP0x xmm15
wolfSSL 13:f67a6c6013ca 1008 #define W_I_TEMPy ymm7
wolfSSL 13:f67a6c6013ca 1009 #define W_K_TEMPy ymm15
wolfSSL 13:f67a6c6013ca 1010 #define W_K_TEMPx xmm15
wolfSSL 13:f67a6c6013ca 1011 #define W_0y ymm12
wolfSSL 13:f67a6c6013ca 1012 #define W_4y ymm4
wolfSSL 13:f67a6c6013ca 1013 #define W_8y ymm5
wolfSSL 13:f67a6c6013ca 1014 #define W_12y ymm6
wolfSSL 13:f67a6c6013ca 1015
wolfSSL 13:f67a6c6013ca 1016 #define YMM_REGs
wolfSSL 13:f67a6c6013ca 1017 /* Registers are saved in Sha512Update/Final */
wolfSSL 13:f67a6c6013ca 1018 /* "%ymm7","%ymm8","%ymm9","%ymm10","%ymm11","%ymm12","%ymm13","%ymm14","%ymm15"*/
wolfSSL 13:f67a6c6013ca 1019
wolfSSL 13:f67a6c6013ca 1020 #define MOVE_15_to_16(w_i_16, w_i_15, w_i_7)\
wolfSSL 13:f67a6c6013ca 1021 __asm__ volatile("vperm2i128 $0x01, %%"#w_i_15", %%"#w_i_15", %%"#w_i_15" ":::YMM_REGs);\
wolfSSL 13:f67a6c6013ca 1022 __asm__ volatile("vpblendd $0x08, %%"#w_i_15", %%"#w_i_7", %%"#w_i_16" ":::YMM_REGs);\
wolfSSL 13:f67a6c6013ca 1023 __asm__ volatile("vperm2i128 $0x01, %%"#w_i_7", %%"#w_i_7", %%"#w_i_15" ":::YMM_REGs);\
wolfSSL 13:f67a6c6013ca 1024 __asm__ volatile("vpblendd $0x80, %%"#w_i_15", %%"#w_i_16", %%"#w_i_16" ":::YMM_REGs);\
wolfSSL 13:f67a6c6013ca 1025 __asm__ volatile("vpshufd $0x93, %%"#w_i_16", %%"#w_i_16" ":::YMM_REGs);\
wolfSSL 13:f67a6c6013ca 1026
wolfSSL 13:f67a6c6013ca 1027 #define MOVE_7_to_15(w_i_15, w_i_7)\
wolfSSL 13:f67a6c6013ca 1028 __asm__ volatile("vmovdqu %%"#w_i_7", %%"#w_i_15" ":::YMM_REGs);\
wolfSSL 13:f67a6c6013ca 1029
wolfSSL 13:f67a6c6013ca 1030 #define MOVE_I_to_7(w_i_7, w_i)\
wolfSSL 13:f67a6c6013ca 1031 __asm__ volatile("vperm2i128 $0x01, %%"#w_i", %%"#w_i", %%"#w_i_7" ":::YMM_REGs);\
wolfSSL 13:f67a6c6013ca 1032 __asm__ volatile("vpblendd $0x01, %%"#w_i_7", %%"#w_i", %%"#w_i_7" ":::YMM_REGs);\
wolfSSL 13:f67a6c6013ca 1033 __asm__ volatile("vpshufd $0x39, %%"#w_i_7", %%"#w_i_7" ":::YMM_REGs);\
wolfSSL 13:f67a6c6013ca 1034
wolfSSL 13:f67a6c6013ca 1035 #define MOVE_I_to_2(w_i_2, w_i)\
wolfSSL 13:f67a6c6013ca 1036 __asm__ volatile("vperm2i128 $0x01, %%"#w_i", %%"#w_i", %%"#w_i_2" ":::YMM_REGs);\
wolfSSL 13:f67a6c6013ca 1037 __asm__ volatile("vpshufd $0x0e, %%"#w_i_2", %%"#w_i_2" ":::YMM_REGs);\
wolfSSL 13:f67a6c6013ca 1038
wolfSSL 13:f67a6c6013ca 1039 #endif /* HAVE_INTEL_AVX2 */
wolfSSL 13:f67a6c6013ca 1040
wolfSSL 13:f67a6c6013ca 1041
wolfSSL 13:f67a6c6013ca 1042 /*** Transform Body ***/
wolfSSL 13:f67a6c6013ca 1043 #if defined(HAVE_INTEL_AVX1)
wolfSSL 13:f67a6c6013ca 1044 static int Transform_AVX1(Sha512* sha512)
wolfSSL 13:f67a6c6013ca 1045 {
wolfSSL 13:f67a6c6013ca 1046 const word64* K = K512;
wolfSSL 13:f67a6c6013ca 1047 word64 W_X[16+4] = {0};
wolfSSL 13:f67a6c6013ca 1048 word32 j;
wolfSSL 13:f67a6c6013ca 1049 word64 T[8];
wolfSSL 13:f67a6c6013ca 1050
wolfSSL 13:f67a6c6013ca 1051 /* Copy digest to working vars */
wolfSSL 13:f67a6c6013ca 1052 XMEMCPY(T, sha512->digest, sizeof(T));
wolfSSL 13:f67a6c6013ca 1053
wolfSSL 13:f67a6c6013ca 1054 W_from_buff(W_X, sha512->buffer);
wolfSSL 13:f67a6c6013ca 1055 for (j = 0; j < 80; j += 16) {
wolfSSL 13:f67a6c6013ca 1056 Rx_1( 0); Block_0_1(W_X); Rx_2( 0); Block_0_2(W_X); Rx_3( 0); Block_0_3();
wolfSSL 13:f67a6c6013ca 1057 Rx_1( 1); Block_0_4(); Rx_2( 1); Block_0_5(); Rx_3( 1); Block_0_6(W_X);
wolfSSL 13:f67a6c6013ca 1058 Rx_1( 2); Block_0_7(W_X); Rx_2( 2); Block_0_8(W_X); Rx_3( 2); Block_0_9();
wolfSSL 13:f67a6c6013ca 1059 Rx_1( 3); Block_0_10();Rx_2( 3); Block_0_11();Rx_3( 3); Block_0_12(W_X);
wolfSSL 13:f67a6c6013ca 1060
wolfSSL 13:f67a6c6013ca 1061 Rx_1( 4); Block_4_1(W_X); Rx_2( 4); Block_4_2(W_X); Rx_3( 4); Block_4_3();
wolfSSL 13:f67a6c6013ca 1062 Rx_1( 5); Block_4_4(); Rx_2( 5); Block_4_5(); Rx_3( 5); Block_4_6(W_X);
wolfSSL 13:f67a6c6013ca 1063 Rx_1( 6); Block_4_7(W_X); Rx_2( 6); Block_4_8(W_X); Rx_3( 6); Block_4_9();
wolfSSL 13:f67a6c6013ca 1064 Rx_1( 7); Block_4_10();Rx_2( 7); Block_4_11();Rx_3( 7); Block_4_12(W_X);
wolfSSL 13:f67a6c6013ca 1065
wolfSSL 13:f67a6c6013ca 1066 Rx_1( 8); Block_8_1(W_X); Rx_2( 8); Block_8_2(W_X); Rx_3( 8); Block_8_3();
wolfSSL 13:f67a6c6013ca 1067 Rx_1( 9); Block_8_4(); Rx_2( 9); Block_8_5(); Rx_3( 9); Block_8_6(W_X);
wolfSSL 13:f67a6c6013ca 1068 Rx_1(10); Block_8_7(W_X); Rx_2(10); Block_8_8(W_X); Rx_3(10); Block_8_9();
wolfSSL 13:f67a6c6013ca 1069 Rx_1(11); Block_8_10();Rx_2(11); Block_8_11();Rx_3(11); Block_8_12(W_X);
wolfSSL 13:f67a6c6013ca 1070
wolfSSL 13:f67a6c6013ca 1071 Rx_1(12); Block_12_1(W_X); Rx_2(12); Block_12_2(W_X); Rx_3(12); Block_12_3();
wolfSSL 13:f67a6c6013ca 1072 Rx_1(13); Block_12_4(); Rx_2(13); Block_12_5(); Rx_3(13); Block_12_6(W_X);
wolfSSL 13:f67a6c6013ca 1073 Rx_1(14); Block_12_7(W_X); Rx_2(14); Block_12_8(W_X); Rx_3(14); Block_12_9();
wolfSSL 13:f67a6c6013ca 1074 Rx_1(15); Block_12_10();Rx_2(15); Block_12_11();Rx_3(15); Block_12_12(W_X);
wolfSSL 13:f67a6c6013ca 1075 }
wolfSSL 13:f67a6c6013ca 1076
wolfSSL 13:f67a6c6013ca 1077 /* Add the working vars back into digest */
wolfSSL 13:f67a6c6013ca 1078 sha512->digest[0] += a(0);
wolfSSL 13:f67a6c6013ca 1079 sha512->digest[1] += b(0);
wolfSSL 13:f67a6c6013ca 1080 sha512->digest[2] += c(0);
wolfSSL 13:f67a6c6013ca 1081 sha512->digest[3] += d(0);
wolfSSL 13:f67a6c6013ca 1082 sha512->digest[4] += e(0);
wolfSSL 13:f67a6c6013ca 1083 sha512->digest[5] += f(0);
wolfSSL 13:f67a6c6013ca 1084 sha512->digest[6] += g(0);
wolfSSL 13:f67a6c6013ca 1085 sha512->digest[7] += h(0);
wolfSSL 13:f67a6c6013ca 1086
wolfSSL 13:f67a6c6013ca 1087 /* Wipe variables */
wolfSSL 13:f67a6c6013ca 1088 #if !defined(HAVE_INTEL_AVX1) && !defined(HAVE_INTEL_AVX2)
wolfSSL 13:f67a6c6013ca 1089 XMEMSET(W_X, 0, sizeof(word64) * 16);
wolfSSL 13:f67a6c6013ca 1090 #endif
wolfSSL 13:f67a6c6013ca 1091 XMEMSET(T, 0, sizeof(T));
wolfSSL 13:f67a6c6013ca 1092
wolfSSL 13:f67a6c6013ca 1093 return 0;
wolfSSL 13:f67a6c6013ca 1094 }
wolfSSL 13:f67a6c6013ca 1095 #endif /* HAVE_INTEL_AVX1 */
wolfSSL 13:f67a6c6013ca 1096
wolfSSL 13:f67a6c6013ca 1097 #if defined(HAVE_INTEL_AVX2) && defined(HAVE_INTEL_AVX1) && defined(HAVE_INTEL_RORX)
wolfSSL 13:f67a6c6013ca 1098 static int Transform_AVX1_RORX(Sha512* sha512)
wolfSSL 13:f67a6c6013ca 1099 {
wolfSSL 13:f67a6c6013ca 1100 const word64* K = K512;
wolfSSL 13:f67a6c6013ca 1101 word64 W_X[16+4] = {0};
wolfSSL 13:f67a6c6013ca 1102 word32 j;
wolfSSL 13:f67a6c6013ca 1103 word64 T[8];
wolfSSL 13:f67a6c6013ca 1104
wolfSSL 13:f67a6c6013ca 1105 /* Copy digest to working vars */
wolfSSL 13:f67a6c6013ca 1106 XMEMCPY(T, sha512->digest, sizeof(T));
wolfSSL 13:f67a6c6013ca 1107
wolfSSL 13:f67a6c6013ca 1108 W_from_buff(W_X, sha512->buffer);
wolfSSL 13:f67a6c6013ca 1109 for (j = 0; j < 80; j += 16) {
wolfSSL 13:f67a6c6013ca 1110 Rx_RORX_1( 0); Block_0_1(W_X); Rx_RORX_2( 0); Block_0_2(W_X);
wolfSSL 13:f67a6c6013ca 1111 Rx_RORX_3( 0); Block_0_3();
wolfSSL 13:f67a6c6013ca 1112 Rx_RORX_1( 1); Block_0_4(); Rx_RORX_2( 1); Block_0_5();
wolfSSL 13:f67a6c6013ca 1113 Rx_RORX_3( 1); Block_0_6(W_X);
wolfSSL 13:f67a6c6013ca 1114 Rx_RORX_1( 2); Block_0_7(W_X); Rx_RORX_2( 2); Block_0_8(W_X);
wolfSSL 13:f67a6c6013ca 1115 Rx_RORX_3( 2); Block_0_9();
wolfSSL 13:f67a6c6013ca 1116 Rx_RORX_1( 3); Block_0_10();Rx_RORX_2( 3); Block_0_11();
wolfSSL 13:f67a6c6013ca 1117 Rx_RORX_3( 3); Block_0_12(W_X);
wolfSSL 13:f67a6c6013ca 1118
wolfSSL 13:f67a6c6013ca 1119 Rx_RORX_1( 4); Block_4_1(W_X); Rx_RORX_2( 4); Block_4_2(W_X);
wolfSSL 13:f67a6c6013ca 1120 Rx_RORX_3( 4); Block_4_3();
wolfSSL 13:f67a6c6013ca 1121 Rx_RORX_1( 5); Block_4_4(); Rx_RORX_2( 5); Block_4_5();
wolfSSL 13:f67a6c6013ca 1122 Rx_RORX_3( 5); Block_4_6(W_X);
wolfSSL 13:f67a6c6013ca 1123 Rx_RORX_1( 6); Block_4_7(W_X); Rx_RORX_2( 6); Block_4_8(W_X);
wolfSSL 13:f67a6c6013ca 1124 Rx_RORX_3( 6); Block_4_9();
wolfSSL 13:f67a6c6013ca 1125 Rx_RORX_1( 7); Block_4_10();Rx_RORX_2( 7); Block_4_11();
wolfSSL 13:f67a6c6013ca 1126 Rx_RORX_3( 7); Block_4_12(W_X);
wolfSSL 13:f67a6c6013ca 1127
wolfSSL 13:f67a6c6013ca 1128 Rx_RORX_1( 8); Block_8_1(W_X); Rx_RORX_2( 8); Block_8_2(W_X);
wolfSSL 13:f67a6c6013ca 1129 Rx_RORX_3( 8); Block_8_3();
wolfSSL 13:f67a6c6013ca 1130 Rx_RORX_1( 9); Block_8_4(); Rx_RORX_2( 9); Block_8_5();
wolfSSL 13:f67a6c6013ca 1131 Rx_RORX_3( 9); Block_8_6(W_X);
wolfSSL 13:f67a6c6013ca 1132 Rx_RORX_1(10); Block_8_7(W_X); Rx_RORX_2(10); Block_8_8(W_X);
wolfSSL 13:f67a6c6013ca 1133 Rx_RORX_3(10); Block_8_9();
wolfSSL 13:f67a6c6013ca 1134 Rx_RORX_1(11); Block_8_10();Rx_RORX_2(11); Block_8_11();
wolfSSL 13:f67a6c6013ca 1135 Rx_RORX_3(11); Block_8_12(W_X);
wolfSSL 13:f67a6c6013ca 1136
wolfSSL 13:f67a6c6013ca 1137 Rx_RORX_1(12); Block_12_1(W_X); Rx_RORX_2(12); Block_12_2(W_X);
wolfSSL 13:f67a6c6013ca 1138 Rx_RORX_3(12); Block_12_3();
wolfSSL 13:f67a6c6013ca 1139 Rx_RORX_1(13); Block_12_4(); Rx_RORX_2(13); Block_12_5();
wolfSSL 13:f67a6c6013ca 1140 Rx_RORX_3(13); Block_12_6(W_X);
wolfSSL 13:f67a6c6013ca 1141 Rx_RORX_1(14); Block_12_7(W_X); Rx_RORX_2(14); Block_12_8(W_X);
wolfSSL 13:f67a6c6013ca 1142 Rx_RORX_3(14); Block_12_9();
wolfSSL 13:f67a6c6013ca 1143 Rx_RORX_1(15); Block_12_10();Rx_RORX_2(15); Block_12_11();
wolfSSL 13:f67a6c6013ca 1144 Rx_RORX_3(15); Block_12_12(W_X);
wolfSSL 13:f67a6c6013ca 1145 }
wolfSSL 13:f67a6c6013ca 1146
wolfSSL 13:f67a6c6013ca 1147 /* Add the working vars back into digest */
wolfSSL 13:f67a6c6013ca 1148 sha512->digest[0] += a(0);
wolfSSL 13:f67a6c6013ca 1149 sha512->digest[1] += b(0);
wolfSSL 13:f67a6c6013ca 1150 sha512->digest[2] += c(0);
wolfSSL 13:f67a6c6013ca 1151 sha512->digest[3] += d(0);
wolfSSL 13:f67a6c6013ca 1152 sha512->digest[4] += e(0);
wolfSSL 13:f67a6c6013ca 1153 sha512->digest[5] += f(0);
wolfSSL 13:f67a6c6013ca 1154 sha512->digest[6] += g(0);
wolfSSL 13:f67a6c6013ca 1155 sha512->digest[7] += h(0);
wolfSSL 13:f67a6c6013ca 1156
wolfSSL 13:f67a6c6013ca 1157 /* Wipe variables */
wolfSSL 13:f67a6c6013ca 1158 #if !defined(HAVE_INTEL_AVX1)&&!defined(HAVE_INTEL_AVX2)
wolfSSL 13:f67a6c6013ca 1159 XMEMSET(W_X, 0, sizeof(word64) * 16);
wolfSSL 13:f67a6c6013ca 1160 #endif
wolfSSL 13:f67a6c6013ca 1161 XMEMSET(T, 0, sizeof(T));
wolfSSL 13:f67a6c6013ca 1162
wolfSSL 13:f67a6c6013ca 1163 return 0;
wolfSSL 13:f67a6c6013ca 1164 }
wolfSSL 13:f67a6c6013ca 1165 #endif /* HAVE_INTEL_AVX2 && HAVE_INTEL_AVX1 && HAVE_INTEL_RORX */
wolfSSL 13:f67a6c6013ca 1166
wolfSSL 13:f67a6c6013ca 1167 #if defined(HAVE_INTEL_AVX2)
wolfSSL 13:f67a6c6013ca 1168
wolfSSL 13:f67a6c6013ca 1169 #define s0_1y(dest, src) AVX2_S(dest, src, 1);
wolfSSL 13:f67a6c6013ca 1170 #define s0_2y(dest, src) AVX2_S(G_TEMPy, src, 8); XORy(dest, G_TEMPy, dest);
wolfSSL 13:f67a6c6013ca 1171 #define s0_3y(dest, src) AVX2_R(G_TEMPy, src, 7); XORy(dest, G_TEMPy, dest);
wolfSSL 13:f67a6c6013ca 1172
wolfSSL 13:f67a6c6013ca 1173 #define s1_1y(dest, src) AVX2_S(dest, src, 19);
wolfSSL 13:f67a6c6013ca 1174 #define s1_2y(dest, src) AVX2_S(G_TEMPy, src, 61); XORy(dest, G_TEMPy, dest);
wolfSSL 13:f67a6c6013ca 1175 #define s1_3y(dest, src) AVX2_R(G_TEMPy, src, 6); XORy(dest, G_TEMPy, dest);
wolfSSL 13:f67a6c6013ca 1176
wolfSSL 13:f67a6c6013ca 1177 #define s0_y(dest, src) s0_1y(dest, src); s0_2y(dest, src); s0_3y(dest, src)
wolfSSL 13:f67a6c6013ca 1178 #define s1_y(dest, src) s1_1y(dest, src); s1_2y(dest, src); s1_3y(dest, src)
wolfSSL 13:f67a6c6013ca 1179
wolfSSL 13:f67a6c6013ca 1180
wolfSSL 13:f67a6c6013ca 1181 #define Block_Y_xx_1(i, w_0, w_4, w_8, w_12)\
wolfSSL 13:f67a6c6013ca 1182 MOVE_W_to_W_I_15(W_I_15y, w_0, w_4);\
wolfSSL 13:f67a6c6013ca 1183 MOVE_W_to_W_I_7 (W_I_7y, w_8, w_12);\
wolfSSL 13:f67a6c6013ca 1184 MOVE_W_to_W_I_2 (W_I_2y, w_12);\
wolfSSL 13:f67a6c6013ca 1185
wolfSSL 13:f67a6c6013ca 1186 #define Block_Y_xx_2(i, w_0, w_4, w_8, w_12)\
wolfSSL 13:f67a6c6013ca 1187 s0_1y (YMM_TEMP0, W_I_15y);\
wolfSSL 13:f67a6c6013ca 1188
wolfSSL 13:f67a6c6013ca 1189 #define Block_Y_xx_3(i, w_0, w_4, w_8, w_12)\
wolfSSL 13:f67a6c6013ca 1190 s0_2y (YMM_TEMP0, W_I_15y);\
wolfSSL 13:f67a6c6013ca 1191
wolfSSL 13:f67a6c6013ca 1192 #define Block_Y_xx_4(i, w_0, w_4, w_8, w_12)\
wolfSSL 13:f67a6c6013ca 1193 s0_3y (YMM_TEMP0, W_I_15y);\
wolfSSL 13:f67a6c6013ca 1194
wolfSSL 13:f67a6c6013ca 1195 #define Block_Y_xx_5(i, w_0, w_4, w_8, w_12)\
wolfSSL 13:f67a6c6013ca 1196 ADDy(W_I_TEMPy, w_0, YMM_TEMP0);\
wolfSSL 13:f67a6c6013ca 1197
wolfSSL 13:f67a6c6013ca 1198 #define Block_Y_xx_6(i, w_0, w_4, w_8, w_12)\
wolfSSL 13:f67a6c6013ca 1199 ADDy(W_I_TEMPy, W_I_TEMPy, W_I_7y);\
wolfSSL 13:f67a6c6013ca 1200 s1_1y (YMM_TEMP0, W_I_2y);\
wolfSSL 13:f67a6c6013ca 1201
wolfSSL 13:f67a6c6013ca 1202 #define Block_Y_xx_7(i, w_0, w_4, w_8, w_12)\
wolfSSL 13:f67a6c6013ca 1203 s1_2y (YMM_TEMP0, W_I_2y);\
wolfSSL 13:f67a6c6013ca 1204
wolfSSL 13:f67a6c6013ca 1205 #define Block_Y_xx_8(i, w_0, w_4, w_8, w_12)\
wolfSSL 13:f67a6c6013ca 1206 s1_3y (YMM_TEMP0, W_I_2y);\
wolfSSL 13:f67a6c6013ca 1207 ADDy(w_0, W_I_TEMPy, YMM_TEMP0);\
wolfSSL 13:f67a6c6013ca 1208
wolfSSL 13:f67a6c6013ca 1209 #define Block_Y_xx_9(i, w_0, w_4, w_8, w_12)\
wolfSSL 13:f67a6c6013ca 1210 FEEDBACK1_to_W_I_2(W_I_2y, w_0);\
wolfSSL 13:f67a6c6013ca 1211
wolfSSL 13:f67a6c6013ca 1212 #define Block_Y_xx_10(i, w_0, w_4, w_8, w_12) \
wolfSSL 13:f67a6c6013ca 1213 s1_1y (YMM_TEMP0, W_I_2y);\
wolfSSL 13:f67a6c6013ca 1214
wolfSSL 13:f67a6c6013ca 1215 #define Block_Y_xx_11(i, w_0, w_4, w_8, w_12) \
wolfSSL 13:f67a6c6013ca 1216 s1_2y (YMM_TEMP0, W_I_2y);\
wolfSSL 13:f67a6c6013ca 1217
wolfSSL 13:f67a6c6013ca 1218 #define Block_Y_xx_12(i, w_0, w_4, w_8, w_12)\
wolfSSL 13:f67a6c6013ca 1219 s1_3y (YMM_TEMP0, W_I_2y);\
wolfSSL 13:f67a6c6013ca 1220 ADDy(w_0, W_I_TEMPy, YMM_TEMP0);\
wolfSSL 13:f67a6c6013ca 1221 MOVE_to_MEMy(w,0, w_4);\
wolfSSL 13:f67a6c6013ca 1222
wolfSSL 13:f67a6c6013ca 1223
wolfSSL 13:f67a6c6013ca 1224 static INLINE void Block_Y_0_1(void) { Block_Y_xx_1(0, W_0y, W_4y, W_8y, W_12y); }
wolfSSL 13:f67a6c6013ca 1225 static INLINE void Block_Y_0_2(void) { Block_Y_xx_2(0, W_0y, W_4y, W_8y, W_12y); }
wolfSSL 13:f67a6c6013ca 1226 static INLINE void Block_Y_0_3(void) { Block_Y_xx_3(0, W_0y, W_4y, W_8y, W_12y); }
wolfSSL 13:f67a6c6013ca 1227 static INLINE void Block_Y_0_4(void) { Block_Y_xx_4(0, W_0y, W_4y, W_8y, W_12y); }
wolfSSL 13:f67a6c6013ca 1228 static INLINE void Block_Y_0_5(void) { Block_Y_xx_5(0, W_0y, W_4y, W_8y, W_12y); }
wolfSSL 13:f67a6c6013ca 1229 static INLINE void Block_Y_0_6(void) { Block_Y_xx_6(0, W_0y, W_4y, W_8y, W_12y); }
wolfSSL 13:f67a6c6013ca 1230 static INLINE void Block_Y_0_7(void) { Block_Y_xx_7(0, W_0y, W_4y, W_8y, W_12y); }
wolfSSL 13:f67a6c6013ca 1231 static INLINE void Block_Y_0_8(void) { Block_Y_xx_8(0, W_0y, W_4y, W_8y, W_12y); }
wolfSSL 13:f67a6c6013ca 1232 static INLINE void Block_Y_0_9(void) { Block_Y_xx_9(0, W_0y, W_4y, W_8y, W_12y); }
wolfSSL 13:f67a6c6013ca 1233 static INLINE void Block_Y_0_10(void){ Block_Y_xx_10(0, W_0y, W_4y, W_8y, W_12y); }
wolfSSL 13:f67a6c6013ca 1234 static INLINE void Block_Y_0_11(void){ Block_Y_xx_11(0, W_0y, W_4y, W_8y, W_12y); }
wolfSSL 13:f67a6c6013ca 1235 static INLINE void Block_Y_0_12(word64 *w){ Block_Y_xx_12(0, W_0y, W_4y, W_8y, W_12y); }
wolfSSL 13:f67a6c6013ca 1236
wolfSSL 13:f67a6c6013ca 1237 static INLINE void Block_Y_4_1(void) { Block_Y_xx_1(4, W_4y, W_8y, W_12y, W_0y); }
wolfSSL 13:f67a6c6013ca 1238 static INLINE void Block_Y_4_2(void) { Block_Y_xx_2(4, W_4y, W_8y, W_12y, W_0y); }
wolfSSL 13:f67a6c6013ca 1239 static INLINE void Block_Y_4_3(void) { Block_Y_xx_3(4, W_4y, W_8y, W_12y, W_0y); }
wolfSSL 13:f67a6c6013ca 1240 static INLINE void Block_Y_4_4(void) { Block_Y_xx_4(4, W_4y, W_8y, W_12y, W_0y); }
wolfSSL 13:f67a6c6013ca 1241 static INLINE void Block_Y_4_5(void) { Block_Y_xx_5(4, W_4y, W_8y, W_12y, W_0y); }
wolfSSL 13:f67a6c6013ca 1242 static INLINE void Block_Y_4_6(void) { Block_Y_xx_6(4, W_4y, W_8y, W_12y, W_0y); }
wolfSSL 13:f67a6c6013ca 1243 static INLINE void Block_Y_4_7(void) { Block_Y_xx_7(4, W_4y, W_8y, W_12y, W_0y); }
wolfSSL 13:f67a6c6013ca 1244 static INLINE void Block_Y_4_8(void) { Block_Y_xx_8(4, W_4y, W_8y, W_12y, W_0y); }
wolfSSL 13:f67a6c6013ca 1245 static INLINE void Block_Y_4_9(void) { Block_Y_xx_9(4, W_4y, W_8y, W_12y, W_0y); }
wolfSSL 13:f67a6c6013ca 1246 static INLINE void Block_Y_4_10(void) { Block_Y_xx_10(4, W_4y, W_8y, W_12y, W_0y); }
wolfSSL 13:f67a6c6013ca 1247 static INLINE void Block_Y_4_11(void) { Block_Y_xx_11(4, W_4y, W_8y, W_12y, W_0y); }
wolfSSL 13:f67a6c6013ca 1248 static INLINE void Block_Y_4_12(word64 *w) { Block_Y_xx_12(4, W_4y, W_8y, W_12y, W_0y); }
wolfSSL 13:f67a6c6013ca 1249
wolfSSL 13:f67a6c6013ca 1250 static INLINE void Block_Y_8_1(void) { Block_Y_xx_1(8, W_8y, W_12y, W_0y, W_4y); }
wolfSSL 13:f67a6c6013ca 1251 static INLINE void Block_Y_8_2(void) { Block_Y_xx_2(8, W_8y, W_12y, W_0y, W_4y); }
wolfSSL 13:f67a6c6013ca 1252 static INLINE void Block_Y_8_3(void) { Block_Y_xx_3(8, W_8y, W_12y, W_0y, W_4y); }
wolfSSL 13:f67a6c6013ca 1253 static INLINE void Block_Y_8_4(void) { Block_Y_xx_4(8, W_8y, W_12y, W_0y, W_4y); }
wolfSSL 13:f67a6c6013ca 1254 static INLINE void Block_Y_8_5(void) { Block_Y_xx_5(8, W_8y, W_12y, W_0y, W_4y); }
wolfSSL 13:f67a6c6013ca 1255 static INLINE void Block_Y_8_6(void) { Block_Y_xx_6(8, W_8y, W_12y, W_0y, W_4y); }
wolfSSL 13:f67a6c6013ca 1256 static INLINE void Block_Y_8_7(void) { Block_Y_xx_7(8, W_8y, W_12y, W_0y, W_4y); }
wolfSSL 13:f67a6c6013ca 1257 static INLINE void Block_Y_8_8(void) { Block_Y_xx_8(8, W_8y, W_12y, W_0y, W_4y); }
wolfSSL 13:f67a6c6013ca 1258 static INLINE void Block_Y_8_9(void) { Block_Y_xx_9(8, W_8y, W_12y, W_0y, W_4y); }
wolfSSL 13:f67a6c6013ca 1259 static INLINE void Block_Y_8_10(void) { Block_Y_xx_10(8, W_8y, W_12y, W_0y, W_4y); }
wolfSSL 13:f67a6c6013ca 1260 static INLINE void Block_Y_8_11(void) { Block_Y_xx_11(8, W_8y, W_12y, W_0y, W_4y); }
wolfSSL 13:f67a6c6013ca 1261 static INLINE void Block_Y_8_12(word64 *w) { Block_Y_xx_12(8, W_8y, W_12y, W_0y, W_4y); }
wolfSSL 13:f67a6c6013ca 1262
wolfSSL 13:f67a6c6013ca 1263 static INLINE void Block_Y_12_1(void) { Block_Y_xx_1(12, W_12y, W_0y, W_4y, W_8y); }
wolfSSL 13:f67a6c6013ca 1264 static INLINE void Block_Y_12_2(void) { Block_Y_xx_2(12, W_12y, W_0y, W_4y, W_8y); }
wolfSSL 13:f67a6c6013ca 1265 static INLINE void Block_Y_12_3(void) { Block_Y_xx_3(12, W_12y, W_0y, W_4y, W_8y); }
wolfSSL 13:f67a6c6013ca 1266 static INLINE void Block_Y_12_4(void) { Block_Y_xx_4(12, W_12y, W_0y, W_4y, W_8y); }
wolfSSL 13:f67a6c6013ca 1267 static INLINE void Block_Y_12_5(void) { Block_Y_xx_5(12, W_12y, W_0y, W_4y, W_8y); }
wolfSSL 13:f67a6c6013ca 1268 static INLINE void Block_Y_12_6(void) { Block_Y_xx_6(12, W_12y, W_0y, W_4y, W_8y); }
wolfSSL 13:f67a6c6013ca 1269 static INLINE void Block_Y_12_7(void) { Block_Y_xx_7(12, W_12y, W_0y, W_4y, W_8y); }
wolfSSL 13:f67a6c6013ca 1270 static INLINE void Block_Y_12_8(void) { Block_Y_xx_8(12, W_12y, W_0y, W_4y, W_8y); }
wolfSSL 13:f67a6c6013ca 1271 static INLINE void Block_Y_12_9(void) { Block_Y_xx_9(12, W_12y, W_0y, W_4y, W_8y); }
wolfSSL 13:f67a6c6013ca 1272 static INLINE void Block_Y_12_10(void) { Block_Y_xx_10(12, W_12y, W_0y, W_4y, W_8y); }
wolfSSL 13:f67a6c6013ca 1273 static INLINE void Block_Y_12_11(void) { Block_Y_xx_11(12, W_12y, W_0y, W_4y, W_8y); }
wolfSSL 13:f67a6c6013ca 1274 static INLINE void Block_Y_12_12(word64 *w) { Block_Y_xx_12(12, W_12y, W_0y, W_4y, W_8y); }
wolfSSL 13:f67a6c6013ca 1275
wolfSSL 13:f67a6c6013ca 1276
wolfSSL 13:f67a6c6013ca 1277 static int Transform_AVX2(Sha512* sha512)
wolfSSL 13:f67a6c6013ca 1278 {
wolfSSL 13:f67a6c6013ca 1279 const word64* K = K512;
wolfSSL 13:f67a6c6013ca 1280 word64 w[4];
wolfSSL 13:f67a6c6013ca 1281 word32 j;
wolfSSL 13:f67a6c6013ca 1282 word64 T[8];
wolfSSL 13:f67a6c6013ca 1283
wolfSSL 13:f67a6c6013ca 1284 /* Copy digest to working vars */
wolfSSL 13:f67a6c6013ca 1285 XMEMCPY(T, sha512->digest, sizeof(T));
wolfSSL 13:f67a6c6013ca 1286
wolfSSL 13:f67a6c6013ca 1287 W_from_buff_Y(sha512->buffer);
wolfSSL 13:f67a6c6013ca 1288 MOVE_to_MEMy(w,0, W_0y);
wolfSSL 13:f67a6c6013ca 1289 for (j = 0; j < 80; j += 16) {
wolfSSL 13:f67a6c6013ca 1290 Ry_1( 0, w[0]); Block_Y_0_1(); Ry_2( 0, w[0]); Block_Y_0_2();
wolfSSL 13:f67a6c6013ca 1291 Ry_3( 0, w[0]); Block_Y_0_3();
wolfSSL 13:f67a6c6013ca 1292 Ry_1( 1, w[1]); Block_Y_0_4(); Ry_2( 1, w[1]); Block_Y_0_5();
wolfSSL 13:f67a6c6013ca 1293 Ry_3( 1, w[1]); Block_Y_0_6();
wolfSSL 13:f67a6c6013ca 1294 Ry_1( 2, w[2]); Block_Y_0_7(); Ry_2( 2, w[2]); Block_Y_0_8();
wolfSSL 13:f67a6c6013ca 1295 Ry_3( 2, w[2]); Block_Y_0_9();
wolfSSL 13:f67a6c6013ca 1296 Ry_1( 3, w[3]); Block_Y_0_10();Ry_2( 3, w[3]); Block_Y_0_11();
wolfSSL 13:f67a6c6013ca 1297 Ry_3( 3, w[3]); Block_Y_0_12(w);
wolfSSL 13:f67a6c6013ca 1298
wolfSSL 13:f67a6c6013ca 1299 Ry_1( 4, w[0]); Block_Y_4_1(); Ry_2( 4, w[0]); Block_Y_4_2();
wolfSSL 13:f67a6c6013ca 1300 Ry_3( 4, w[0]); Block_Y_4_3();
wolfSSL 13:f67a6c6013ca 1301 Ry_1( 5, w[1]); Block_Y_4_4(); Ry_2( 5, w[1]); Block_Y_4_5();
wolfSSL 13:f67a6c6013ca 1302 Ry_3( 5, w[1]); Block_Y_4_6();
wolfSSL 13:f67a6c6013ca 1303 Ry_1( 6, w[2]); Block_Y_4_7(); Ry_2( 6, w[2]); Block_Y_4_8();
wolfSSL 13:f67a6c6013ca 1304 Ry_3( 6, w[2]); Block_Y_4_9();
wolfSSL 13:f67a6c6013ca 1305 Ry_1( 7, w[3]); Block_Y_4_10(); Ry_2( 7, w[3]);Block_Y_4_11();
wolfSSL 13:f67a6c6013ca 1306 Ry_3( 7, w[3]);Block_Y_4_12(w);
wolfSSL 13:f67a6c6013ca 1307
wolfSSL 13:f67a6c6013ca 1308 Ry_1( 8, w[0]); Block_Y_8_1(); Ry_2( 8, w[0]); Block_Y_8_2();
wolfSSL 13:f67a6c6013ca 1309 Ry_3( 8, w[0]); Block_Y_8_3();
wolfSSL 13:f67a6c6013ca 1310 Ry_1( 9, w[1]); Block_Y_8_4(); Ry_2( 9, w[1]); Block_Y_8_5();
wolfSSL 13:f67a6c6013ca 1311 Ry_3( 9, w[1]); Block_Y_8_6();
wolfSSL 13:f67a6c6013ca 1312 Ry_1(10, w[2]); Block_Y_8_7(); Ry_2(10, w[2]); Block_Y_8_8();
wolfSSL 13:f67a6c6013ca 1313 Ry_3(10, w[2]); Block_Y_8_9();
wolfSSL 13:f67a6c6013ca 1314 Ry_1(11, w[3]); Block_Y_8_10();Ry_2(11, w[3]); Block_Y_8_11();
wolfSSL 13:f67a6c6013ca 1315 Ry_3(11, w[3]); Block_Y_8_12(w);
wolfSSL 13:f67a6c6013ca 1316
wolfSSL 13:f67a6c6013ca 1317 Ry_1(12, w[0]); Block_Y_12_1(); Ry_2(12, w[0]); Block_Y_12_2();
wolfSSL 13:f67a6c6013ca 1318 Ry_3(12, w[0]); Block_Y_12_3();
wolfSSL 13:f67a6c6013ca 1319 Ry_1(13, w[1]); Block_Y_12_4(); Ry_2(13, w[1]); Block_Y_12_5();
wolfSSL 13:f67a6c6013ca 1320 Ry_3(13, w[1]); Block_Y_12_6();
wolfSSL 13:f67a6c6013ca 1321 Ry_1(14, w[2]); Block_Y_12_7(); Ry_2(14, w[2]); Block_Y_12_8();
wolfSSL 13:f67a6c6013ca 1322 Ry_3(14, w[2]); Block_Y_12_9();
wolfSSL 13:f67a6c6013ca 1323 Ry_1(15, w[3]); Block_Y_12_10();Ry_2(15, w[3]); Block_Y_12_11();
wolfSSL 13:f67a6c6013ca 1324 Ry_3(15, w[3]);Block_Y_12_12(w);
wolfSSL 13:f67a6c6013ca 1325 }
wolfSSL 13:f67a6c6013ca 1326
wolfSSL 13:f67a6c6013ca 1327 /* Add the working vars back into digest */
wolfSSL 13:f67a6c6013ca 1328 sha512->digest[0] += a(0);
wolfSSL 13:f67a6c6013ca 1329 sha512->digest[1] += b(0);
wolfSSL 13:f67a6c6013ca 1330 sha512->digest[2] += c(0);
wolfSSL 13:f67a6c6013ca 1331 sha512->digest[3] += d(0);
wolfSSL 13:f67a6c6013ca 1332 sha512->digest[4] += e(0);
wolfSSL 13:f67a6c6013ca 1333 sha512->digest[5] += f(0);
wolfSSL 13:f67a6c6013ca 1334 sha512->digest[6] += g(0);
wolfSSL 13:f67a6c6013ca 1335 sha512->digest[7] += h(0);
wolfSSL 13:f67a6c6013ca 1336
wolfSSL 13:f67a6c6013ca 1337 /* Wipe variables */
wolfSSL 13:f67a6c6013ca 1338 #if !defined(HAVE_INTEL_AVX1) && !defined(HAVE_INTEL_AVX2)
wolfSSL 13:f67a6c6013ca 1339 XMEMSET(W, 0, sizeof(word64) * 16);
wolfSSL 13:f67a6c6013ca 1340 #endif
wolfSSL 13:f67a6c6013ca 1341 XMEMSET(T, 0, sizeof(T));
wolfSSL 13:f67a6c6013ca 1342
wolfSSL 13:f67a6c6013ca 1343 return 0;
wolfSSL 13:f67a6c6013ca 1344 }
wolfSSL 13:f67a6c6013ca 1345 #endif /* HAVE_INTEL_AVX2 */
wolfSSL 13:f67a6c6013ca 1346
wolfSSL 13:f67a6c6013ca 1347
wolfSSL 13:f67a6c6013ca 1348
wolfSSL 13:f67a6c6013ca 1349 /* -------------------------------------------------------------------------- */
wolfSSL 13:f67a6c6013ca 1350 /* SHA384 */
wolfSSL 13:f67a6c6013ca 1351 /* -------------------------------------------------------------------------- */
wolfSSL 13:f67a6c6013ca 1352 #ifdef WOLFSSL_SHA384
wolfSSL 13:f67a6c6013ca 1353 static int InitSha384(Sha384* sha384)
wolfSSL 13:f67a6c6013ca 1354 {
wolfSSL 13:f67a6c6013ca 1355 if (sha384 == NULL) {
wolfSSL 13:f67a6c6013ca 1356 return BAD_FUNC_ARG;
wolfSSL 13:f67a6c6013ca 1357 }
wolfSSL 13:f67a6c6013ca 1358
wolfSSL 13:f67a6c6013ca 1359 sha384->digest[0] = W64LIT(0xcbbb9d5dc1059ed8);
wolfSSL 13:f67a6c6013ca 1360 sha384->digest[1] = W64LIT(0x629a292a367cd507);
wolfSSL 13:f67a6c6013ca 1361 sha384->digest[2] = W64LIT(0x9159015a3070dd17);
wolfSSL 13:f67a6c6013ca 1362 sha384->digest[3] = W64LIT(0x152fecd8f70e5939);
wolfSSL 13:f67a6c6013ca 1363 sha384->digest[4] = W64LIT(0x67332667ffc00b31);
wolfSSL 13:f67a6c6013ca 1364 sha384->digest[5] = W64LIT(0x8eb44a8768581511);
wolfSSL 13:f67a6c6013ca 1365 sha384->digest[6] = W64LIT(0xdb0c2e0d64f98fa7);
wolfSSL 13:f67a6c6013ca 1366 sha384->digest[7] = W64LIT(0x47b5481dbefa4fa4);
wolfSSL 13:f67a6c6013ca 1367
wolfSSL 13:f67a6c6013ca 1368 sha384->buffLen = 0;
wolfSSL 13:f67a6c6013ca 1369 sha384->loLen = 0;
wolfSSL 13:f67a6c6013ca 1370 sha384->hiLen = 0;
wolfSSL 13:f67a6c6013ca 1371
wolfSSL 13:f67a6c6013ca 1372 return 0;
wolfSSL 13:f67a6c6013ca 1373 }
wolfSSL 13:f67a6c6013ca 1374
wolfSSL 13:f67a6c6013ca 1375 int wc_Sha384Update(Sha384* sha384, const byte* data, word32 len)
wolfSSL 13:f67a6c6013ca 1376 {
wolfSSL 13:f67a6c6013ca 1377 if (sha384 == NULL || (data == NULL && len > 0)) {
wolfSSL 13:f67a6c6013ca 1378 return BAD_FUNC_ARG;
wolfSSL 13:f67a6c6013ca 1379 }
wolfSSL 13:f67a6c6013ca 1380
wolfSSL 13:f67a6c6013ca 1381 #if defined(WOLFSSL_ASYNC_CRYPT) && defined(WC_ASYNC_ENABLE_SHA384)
wolfSSL 13:f67a6c6013ca 1382 if (sha384->asyncDev.marker == WOLFSSL_ASYNC_MARKER_SHA384) {
wolfSSL 13:f67a6c6013ca 1383 #if defined(HAVE_INTEL_QA)
wolfSSL 13:f67a6c6013ca 1384 return IntelQaSymSha384(&sha384->asyncDev, NULL, data, len);
wolfSSL 13:f67a6c6013ca 1385 #endif
wolfSSL 13:f67a6c6013ca 1386 }
wolfSSL 13:f67a6c6013ca 1387 #endif /* WOLFSSL_ASYNC_CRYPT */
wolfSSL 13:f67a6c6013ca 1388
wolfSSL 13:f67a6c6013ca 1389 return Sha512Update((Sha512*)sha384, data, len);
wolfSSL 13:f67a6c6013ca 1390 }
wolfSSL 13:f67a6c6013ca 1391
wolfSSL 13:f67a6c6013ca 1392
wolfSSL 13:f67a6c6013ca 1393 int wc_Sha384Final(Sha384* sha384, byte* hash)
wolfSSL 13:f67a6c6013ca 1394 {
wolfSSL 13:f67a6c6013ca 1395 int ret;
wolfSSL 13:f67a6c6013ca 1396
wolfSSL 13:f67a6c6013ca 1397 if (sha384 == NULL || hash == NULL) {
wolfSSL 13:f67a6c6013ca 1398 return BAD_FUNC_ARG;
wolfSSL 13:f67a6c6013ca 1399 }
wolfSSL 13:f67a6c6013ca 1400
wolfSSL 13:f67a6c6013ca 1401 #if defined(WOLFSSL_ASYNC_CRYPT) && defined(WC_ASYNC_ENABLE_SHA384)
wolfSSL 13:f67a6c6013ca 1402 if (sha384->asyncDev.marker == WOLFSSL_ASYNC_MARKER_SHA384) {
wolfSSL 13:f67a6c6013ca 1403 #if defined(HAVE_INTEL_QA)
wolfSSL 13:f67a6c6013ca 1404 return IntelQaSymSha384(&sha384->asyncDev, hash, NULL,
wolfSSL 13:f67a6c6013ca 1405 SHA384_DIGEST_SIZE);
wolfSSL 13:f67a6c6013ca 1406 #endif
wolfSSL 13:f67a6c6013ca 1407 }
wolfSSL 13:f67a6c6013ca 1408 #endif /* WOLFSSL_ASYNC_CRYPT */
wolfSSL 13:f67a6c6013ca 1409
wolfSSL 13:f67a6c6013ca 1410 ret = Sha512Final((Sha512*)sha384);
wolfSSL 13:f67a6c6013ca 1411 if (ret != 0)
wolfSSL 13:f67a6c6013ca 1412 return ret;
wolfSSL 13:f67a6c6013ca 1413
wolfSSL 13:f67a6c6013ca 1414 XMEMCPY(hash, sha384->digest, SHA384_DIGEST_SIZE);
wolfSSL 13:f67a6c6013ca 1415
wolfSSL 13:f67a6c6013ca 1416 return InitSha384(sha384); /* reset state */
wolfSSL 13:f67a6c6013ca 1417 }
wolfSSL 13:f67a6c6013ca 1418
wolfSSL 13:f67a6c6013ca 1419
wolfSSL 13:f67a6c6013ca 1420 /* Hardware Acceleration */
wolfSSL 13:f67a6c6013ca 1421 #if defined(HAVE_INTEL_AVX1) || defined(HAVE_INTEL_AVX2)
wolfSSL 13:f67a6c6013ca 1422 int wc_InitSha384_ex(Sha384* sha384, void* heap, int devId)
wolfSSL 13:f67a6c6013ca 1423 {
wolfSSL 13:f67a6c6013ca 1424 int ret = InitSha384(sha384);
wolfSSL 13:f67a6c6013ca 1425
wolfSSL 13:f67a6c6013ca 1426 (void)heap;
wolfSSL 13:f67a6c6013ca 1427 (void)devId;
wolfSSL 13:f67a6c6013ca 1428
wolfSSL 13:f67a6c6013ca 1429 Sha512_SetTransform();
wolfSSL 13:f67a6c6013ca 1430
wolfSSL 13:f67a6c6013ca 1431 return ret;
wolfSSL 13:f67a6c6013ca 1432 }
wolfSSL 13:f67a6c6013ca 1433 #else
wolfSSL 13:f67a6c6013ca 1434 int wc_InitSha384_ex(Sha384* sha384, void* heap, int devId)
wolfSSL 13:f67a6c6013ca 1435 {
wolfSSL 13:f67a6c6013ca 1436 int ret;
wolfSSL 13:f67a6c6013ca 1437
wolfSSL 13:f67a6c6013ca 1438 if (sha384 == NULL) {
wolfSSL 13:f67a6c6013ca 1439 return BAD_FUNC_ARG;
wolfSSL 13:f67a6c6013ca 1440 }
wolfSSL 13:f67a6c6013ca 1441
wolfSSL 13:f67a6c6013ca 1442 sha384->heap = heap;
wolfSSL 13:f67a6c6013ca 1443 ret = InitSha384(sha384);
wolfSSL 13:f67a6c6013ca 1444 if (ret != 0)
wolfSSL 13:f67a6c6013ca 1445 return ret;
wolfSSL 13:f67a6c6013ca 1446
wolfSSL 13:f67a6c6013ca 1447 #if defined(WOLFSSL_ASYNC_CRYPT) && defined(WC_ASYNC_ENABLE_SHA384)
wolfSSL 13:f67a6c6013ca 1448 ret = wolfAsync_DevCtxInit(&sha384->asyncDev, WOLFSSL_ASYNC_MARKER_SHA384,
wolfSSL 13:f67a6c6013ca 1449 sha384->heap, devId);
wolfSSL 13:f67a6c6013ca 1450 #else
wolfSSL 13:f67a6c6013ca 1451 (void)devId;
wolfSSL 13:f67a6c6013ca 1452 #endif /* WOLFSSL_ASYNC_CRYPT */
wolfSSL 13:f67a6c6013ca 1453
wolfSSL 13:f67a6c6013ca 1454 return ret;
wolfSSL 13:f67a6c6013ca 1455 }
wolfSSL 13:f67a6c6013ca 1456 #endif
wolfSSL 13:f67a6c6013ca 1457
wolfSSL 13:f67a6c6013ca 1458 int wc_InitSha384(Sha384* sha384)
wolfSSL 13:f67a6c6013ca 1459 {
wolfSSL 13:f67a6c6013ca 1460 return wc_InitSha384_ex(sha384, NULL, INVALID_DEVID);
wolfSSL 13:f67a6c6013ca 1461 }
wolfSSL 13:f67a6c6013ca 1462
wolfSSL 13:f67a6c6013ca 1463 void wc_Sha384Free(Sha384* sha384)
wolfSSL 13:f67a6c6013ca 1464 {
wolfSSL 13:f67a6c6013ca 1465 if (sha384 == NULL)
wolfSSL 13:f67a6c6013ca 1466 return;
wolfSSL 13:f67a6c6013ca 1467
wolfSSL 13:f67a6c6013ca 1468 #if defined(WOLFSSL_ASYNC_CRYPT) && defined(WC_ASYNC_ENABLE_SHA384)
wolfSSL 13:f67a6c6013ca 1469 wolfAsync_DevCtxFree(&sha384->asyncDev, WOLFSSL_ASYNC_MARKER_SHA384);
wolfSSL 13:f67a6c6013ca 1470 #endif /* WOLFSSL_ASYNC_CRYPT */
wolfSSL 13:f67a6c6013ca 1471 }
wolfSSL 13:f67a6c6013ca 1472
wolfSSL 13:f67a6c6013ca 1473 #endif /* WOLFSSL_SHA384 */
wolfSSL 13:f67a6c6013ca 1474
wolfSSL 13:f67a6c6013ca 1475 #endif /* HAVE_FIPS */
wolfSSL 13:f67a6c6013ca 1476
wolfSSL 13:f67a6c6013ca 1477
wolfSSL 13:f67a6c6013ca 1478 int wc_Sha512GetHash(Sha512* sha512, byte* hash)
wolfSSL 13:f67a6c6013ca 1479 {
wolfSSL 13:f67a6c6013ca 1480 int ret;
wolfSSL 13:f67a6c6013ca 1481 Sha512 tmpSha512;
wolfSSL 13:f67a6c6013ca 1482
wolfSSL 13:f67a6c6013ca 1483 if (sha512 == NULL || hash == NULL)
wolfSSL 13:f67a6c6013ca 1484 return BAD_FUNC_ARG;
wolfSSL 13:f67a6c6013ca 1485
wolfSSL 13:f67a6c6013ca 1486 ret = wc_Sha512Copy(sha512, &tmpSha512);
wolfSSL 13:f67a6c6013ca 1487 if (ret == 0) {
wolfSSL 13:f67a6c6013ca 1488 ret = wc_Sha512Final(&tmpSha512, hash);
wolfSSL 13:f67a6c6013ca 1489 }
wolfSSL 13:f67a6c6013ca 1490 return ret;
wolfSSL 13:f67a6c6013ca 1491 }
wolfSSL 13:f67a6c6013ca 1492
wolfSSL 13:f67a6c6013ca 1493 int wc_Sha512Copy(Sha512* src, Sha512* dst)
wolfSSL 13:f67a6c6013ca 1494 {
wolfSSL 13:f67a6c6013ca 1495 int ret = 0;
wolfSSL 13:f67a6c6013ca 1496
wolfSSL 13:f67a6c6013ca 1497 if (src == NULL || dst == NULL)
wolfSSL 13:f67a6c6013ca 1498 return BAD_FUNC_ARG;
wolfSSL 13:f67a6c6013ca 1499
wolfSSL 13:f67a6c6013ca 1500 XMEMCPY(dst, src, sizeof(Sha512));
wolfSSL 13:f67a6c6013ca 1501
wolfSSL 13:f67a6c6013ca 1502 #ifdef WOLFSSL_ASYNC_CRYPT
wolfSSL 13:f67a6c6013ca 1503 ret = wolfAsync_DevCopy(&src->asyncDev, &dst->asyncDev);
wolfSSL 13:f67a6c6013ca 1504 #endif
wolfSSL 13:f67a6c6013ca 1505
wolfSSL 13:f67a6c6013ca 1506 return ret;
wolfSSL 13:f67a6c6013ca 1507 }
wolfSSL 13:f67a6c6013ca 1508
wolfSSL 13:f67a6c6013ca 1509 #ifdef WOLFSSL_SHA384
wolfSSL 13:f67a6c6013ca 1510 int wc_Sha384GetHash(Sha384* sha384, byte* hash)
wolfSSL 13:f67a6c6013ca 1511 {
wolfSSL 13:f67a6c6013ca 1512 int ret;
wolfSSL 13:f67a6c6013ca 1513 Sha384 tmpSha384;
wolfSSL 13:f67a6c6013ca 1514
wolfSSL 13:f67a6c6013ca 1515 if (sha384 == NULL || hash == NULL)
wolfSSL 13:f67a6c6013ca 1516 return BAD_FUNC_ARG;
wolfSSL 13:f67a6c6013ca 1517
wolfSSL 13:f67a6c6013ca 1518 ret = wc_Sha384Copy(sha384, &tmpSha384);
wolfSSL 13:f67a6c6013ca 1519 if (ret == 0) {
wolfSSL 13:f67a6c6013ca 1520 ret = wc_Sha384Final(&tmpSha384, hash);
wolfSSL 13:f67a6c6013ca 1521 }
wolfSSL 13:f67a6c6013ca 1522 return ret;
wolfSSL 13:f67a6c6013ca 1523 }
wolfSSL 13:f67a6c6013ca 1524 int wc_Sha384Copy(Sha384* src, Sha384* dst)
wolfSSL 13:f67a6c6013ca 1525 {
wolfSSL 13:f67a6c6013ca 1526 int ret = 0;
wolfSSL 13:f67a6c6013ca 1527
wolfSSL 13:f67a6c6013ca 1528 if (src == NULL || dst == NULL)
wolfSSL 13:f67a6c6013ca 1529 return BAD_FUNC_ARG;
wolfSSL 13:f67a6c6013ca 1530
wolfSSL 13:f67a6c6013ca 1531 XMEMCPY(dst, src, sizeof(Sha384));
wolfSSL 13:f67a6c6013ca 1532
wolfSSL 13:f67a6c6013ca 1533 #ifdef WOLFSSL_ASYNC_CRYPT
wolfSSL 13:f67a6c6013ca 1534 ret = wolfAsync_DevCopy(&src->asyncDev, &dst->asyncDev);
wolfSSL 13:f67a6c6013ca 1535 #endif
wolfSSL 13:f67a6c6013ca 1536
wolfSSL 13:f67a6c6013ca 1537 return ret;
wolfSSL 13:f67a6c6013ca 1538 }
wolfSSL 13:f67a6c6013ca 1539 #endif /* WOLFSSL_SHA384 */
wolfSSL 13:f67a6c6013ca 1540
wolfSSL 13:f67a6c6013ca 1541 #endif /* WOLFSSL_SHA512 */
wolfSSL 13:f67a6c6013ca 1542