]> git.ipfire.org Git - thirdparty/openssl.git/blob - crypto/sha/sha512.c
projects / thirdparty / openssl.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Raise an error on syscall failure in tls_retry_write_records
[thirdparty/openssl.git] / crypto / sha / sha512.c
1 /*
2 * Copyright 2004-2022 The OpenSSL Project Authors. All Rights Reserved.
3 *
4 * Licensed under the Apache License 2.0 (the "License"). You may not use
5 * this file except in compliance with the License. You can obtain a copy
6 * in the file LICENSE in the source distribution or at
7 * https://www.openssl.org/source/license.html
8 */
9
10 /*
11 * SHA512 low level APIs are deprecated for public use, but still ok for
12 * internal use.
13 */
14 #include "internal/deprecated.h"
15
16 #include <stdio.h>
17 #include <openssl/opensslconf.h>
18 /*-
19 * IMPLEMENTATION NOTES.
20 *
21 * As you might have noticed, 32-bit hash algorithms:
22 *
23 * - permit SHA_LONG to be wider than 32-bit
24 * - optimized versions implement two transform functions: one operating
25 * on [aligned] data in host byte order, and one operating on data in input
26 * stream byte order;
27 * - share common byte-order neutral collector and padding function
28 * implementations, crypto/md32_common.h;
29 *
30 * Neither of the above applies to this SHA-512 implementation. Reasons
31 * [in reverse order] are:
32 *
33 * - it's the only 64-bit hash algorithm for the moment of this writing,
34 * there is no need for common collector/padding implementation [yet];
35 * - by supporting only one transform function [which operates on
36 * *aligned* data in input stream byte order, big-endian in this case]
37 * we minimize burden of maintenance in two ways: a) collector/padding
38 * function is simpler; b) only one transform function to stare at;
39 * - SHA_LONG64 is required to be exactly 64-bit in order to be able to
40 * apply a number of optimizations to mitigate potential performance
41 * penalties caused by previous design decision;
42 *
43 * Caveat lector.
44 *
45 * Implementation relies on the fact that "long long" is 64-bit on
46 * both 32- and 64-bit platforms. If some compiler vendor comes up
47 * with 128-bit long long, adjustment to sha.h would be required.
48 * As this implementation relies on 64-bit integer type, it's totally
49 * inappropriate for platforms which don't support it, most notably
50 * 16-bit platforms.
51 */
52 #include <stdlib.h>
53 #include <string.h>
54
55 #include <openssl/crypto.h>
56 #include <openssl/sha.h>
57 #include <openssl/opensslv.h>
58
59 #include "internal/cryptlib.h"
60 #include "crypto/sha.h"
61
62 #if defined(__i386) || defined(__i386__) || defined(_M_IX86) || \
63 defined(__x86_64) || defined(_M_AMD64) || defined(_M_X64) || \
64 defined(__s390__) || defined(__s390x__) || \
65 defined(__aarch64__) || \
66 defined(SHA512_ASM)
67 # define SHA512_BLOCK_CAN_MANAGE_UNALIGNED_DATA
68 #endif
69
70 #if (defined(_WIN32) || defined(_WIN64)) && !defined(__MINGW32__)
71 # define U64(C) C##UI64
72 #elif defined(__arch64__)
73 # define U64(C) C##UL
74 #else
75 # define U64(C) C##ULL
76 #endif
77
78 int sha512_224_init(SHA512_CTX *c)
79 {
80 c->h[0] = U64(0x8c3d37c819544da2);
81 c->h[1] = U64(0x73e1996689dcd4d6);
82 c->h[2] = U64(0x1dfab7ae32ff9c82);
83 c->h[3] = U64(0x679dd514582f9fcf);
84 c->h[4] = U64(0x0f6d2b697bd44da8);
85 c->h[5] = U64(0x77e36f7304c48942);
86 c->h[6] = U64(0x3f9d85a86a1d36c8);
87 c->h[7] = U64(0x1112e6ad91d692a1);
88
89 c->Nl = 0;
90 c->Nh = 0;
91 c->num = 0;
92 c->md_len = SHA224_DIGEST_LENGTH;
93 return 1;
94 }
95
96 int sha512_256_init(SHA512_CTX *c)
97 {
98 c->h[0] = U64(0x22312194fc2bf72c);
99 c->h[1] = U64(0x9f555fa3c84c64c2);
100 c->h[2] = U64(0x2393b86b6f53b151);
101 c->h[3] = U64(0x963877195940eabd);
102 c->h[4] = U64(0x96283ee2a88effe3);
103 c->h[5] = U64(0xbe5e1e2553863992);
104 c->h[6] = U64(0x2b0199fc2c85b8aa);
105 c->h[7] = U64(0x0eb72ddc81c52ca2);
106
107 c->Nl = 0;
108 c->Nh = 0;
109 c->num = 0;
110 c->md_len = SHA256_DIGEST_LENGTH;
111 return 1;
112 }
113
114 int SHA384_Init(SHA512_CTX *c)
115 {
116 c->h[0] = U64(0xcbbb9d5dc1059ed8);
117 c->h[1] = U64(0x629a292a367cd507);
118 c->h[2] = U64(0x9159015a3070dd17);
119 c->h[3] = U64(0x152fecd8f70e5939);
120 c->h[4] = U64(0x67332667ffc00b31);
121 c->h[5] = U64(0x8eb44a8768581511);
122 c->h[6] = U64(0xdb0c2e0d64f98fa7);
123 c->h[7] = U64(0x47b5481dbefa4fa4);
124
125 c->Nl = 0;
126 c->Nh = 0;
127 c->num = 0;
128 c->md_len = SHA384_DIGEST_LENGTH;
129 return 1;
130 }
131
132 int SHA512_Init(SHA512_CTX *c)
133 {
134 c->h[0] = U64(0x6a09e667f3bcc908);
135 c->h[1] = U64(0xbb67ae8584caa73b);
136 c->h[2] = U64(0x3c6ef372fe94f82b);
137 c->h[3] = U64(0xa54ff53a5f1d36f1);
138 c->h[4] = U64(0x510e527fade682d1);
139 c->h[5] = U64(0x9b05688c2b3e6c1f);
140 c->h[6] = U64(0x1f83d9abfb41bd6b);
141 c->h[7] = U64(0x5be0cd19137e2179);
142
143 c->Nl = 0;
144 c->Nh = 0;
145 c->num = 0;
146 c->md_len = SHA512_DIGEST_LENGTH;
147 return 1;
148 }
149
150 #ifndef SHA512_ASM
151 static
152 #else
153 # ifdef INCLUDE_C_SHA512
154 void sha512_block_data_order_c(SHA512_CTX *ctx, const void *in, size_t num);
155 # endif
156 #endif
157 void sha512_block_data_order(SHA512_CTX *ctx, const void *in, size_t num);
158
159 int SHA512_Final(unsigned char *md, SHA512_CTX *c)
160 {
161 unsigned char *p = (unsigned char *)c->u.p;
162 size_t n = c->num;
163
164 p[n] = 0x80; /* There always is a room for one */
165 n++;
166 if (n > (sizeof(c->u) - 16)) {
167 memset(p + n, 0, sizeof(c->u) - n);
168 n = 0;
169 sha512_block_data_order(c, p, 1);
170 }
171
172 memset(p + n, 0, sizeof(c->u) - 16 - n);
173 #ifdef B_ENDIAN
174 c->u.d[SHA_LBLOCK - 2] = c->Nh;
175 c->u.d[SHA_LBLOCK - 1] = c->Nl;
176 #else
177 p[sizeof(c->u) - 1] = (unsigned char)(c->Nl);
178 p[sizeof(c->u) - 2] = (unsigned char)(c->Nl >> 8);
179 p[sizeof(c->u) - 3] = (unsigned char)(c->Nl >> 16);
180 p[sizeof(c->u) - 4] = (unsigned char)(c->Nl >> 24);
181 p[sizeof(c->u) - 5] = (unsigned char)(c->Nl >> 32);
182 p[sizeof(c->u) - 6] = (unsigned char)(c->Nl >> 40);
183 p[sizeof(c->u) - 7] = (unsigned char)(c->Nl >> 48);
184 p[sizeof(c->u) - 8] = (unsigned char)(c->Nl >> 56);
185 p[sizeof(c->u) - 9] = (unsigned char)(c->Nh);
186 p[sizeof(c->u) - 10] = (unsigned char)(c->Nh >> 8);
187 p[sizeof(c->u) - 11] = (unsigned char)(c->Nh >> 16);
188 p[sizeof(c->u) - 12] = (unsigned char)(c->Nh >> 24);
189 p[sizeof(c->u) - 13] = (unsigned char)(c->Nh >> 32);
190 p[sizeof(c->u) - 14] = (unsigned char)(c->Nh >> 40);
191 p[sizeof(c->u) - 15] = (unsigned char)(c->Nh >> 48);
192 p[sizeof(c->u) - 16] = (unsigned char)(c->Nh >> 56);
193 #endif
194
195 sha512_block_data_order(c, p, 1);
196
197 if (md == 0)
198 return 0;
199
200 switch (c->md_len) {
201 /* Let compiler decide if it's appropriate to unroll... */
202 case SHA224_DIGEST_LENGTH:
203 for (n = 0; n < SHA224_DIGEST_LENGTH / 8; n++) {
204 SHA_LONG64 t = c->h[n];
205
206 *(md++) = (unsigned char)(t >> 56);
207 *(md++) = (unsigned char)(t >> 48);
208 *(md++) = (unsigned char)(t >> 40);
209 *(md++) = (unsigned char)(t >> 32);
210 *(md++) = (unsigned char)(t >> 24);
211 *(md++) = (unsigned char)(t >> 16);
212 *(md++) = (unsigned char)(t >> 8);
213 *(md++) = (unsigned char)(t);
214 }
215 /*
216 * For 224 bits, there are four bytes left over that have to be
217 * processed separately.
218 */
219 {
220 SHA_LONG64 t = c->h[SHA224_DIGEST_LENGTH / 8];
221
222 *(md++) = (unsigned char)(t >> 56);
223 *(md++) = (unsigned char)(t >> 48);
224 *(md++) = (unsigned char)(t >> 40);
225 *(md++) = (unsigned char)(t >> 32);
226 }
227 break;
228 case SHA256_DIGEST_LENGTH:
229 for (n = 0; n < SHA256_DIGEST_LENGTH / 8; n++) {
230 SHA_LONG64 t = c->h[n];
231
232 *(md++) = (unsigned char)(t >> 56);
233 *(md++) = (unsigned char)(t >> 48);
234 *(md++) = (unsigned char)(t >> 40);
235 *(md++) = (unsigned char)(t >> 32);
236 *(md++) = (unsigned char)(t >> 24);
237 *(md++) = (unsigned char)(t >> 16);
238 *(md++) = (unsigned char)(t >> 8);
239 *(md++) = (unsigned char)(t);
240 }
241 break;
242 case SHA384_DIGEST_LENGTH:
243 for (n = 0; n < SHA384_DIGEST_LENGTH / 8; n++) {
244 SHA_LONG64 t = c->h[n];
245
246 *(md++) = (unsigned char)(t >> 56);
247 *(md++) = (unsigned char)(t >> 48);
248 *(md++) = (unsigned char)(t >> 40);
249 *(md++) = (unsigned char)(t >> 32);
250 *(md++) = (unsigned char)(t >> 24);
251 *(md++) = (unsigned char)(t >> 16);
252 *(md++) = (unsigned char)(t >> 8);
253 *(md++) = (unsigned char)(t);
254 }
255 break;
256 case SHA512_DIGEST_LENGTH:
257 for (n = 0; n < SHA512_DIGEST_LENGTH / 8; n++) {
258 SHA_LONG64 t = c->h[n];
259
260 *(md++) = (unsigned char)(t >> 56);
261 *(md++) = (unsigned char)(t >> 48);
262 *(md++) = (unsigned char)(t >> 40);
263 *(md++) = (unsigned char)(t >> 32);
264 *(md++) = (unsigned char)(t >> 24);
265 *(md++) = (unsigned char)(t >> 16);
266 *(md++) = (unsigned char)(t >> 8);
267 *(md++) = (unsigned char)(t);
268 }
269 break;
270 /* ... as well as make sure md_len is not abused. */
271 default:
272 return 0;
273 }
274
275 return 1;
276 }
277
278 int SHA384_Final(unsigned char *md, SHA512_CTX *c)
279 {
280 return SHA512_Final(md, c);
281 }
282
283 int SHA512_Update(SHA512_CTX *c, const void *_data, size_t len)
284 {
285 SHA_LONG64 l;
286 unsigned char *p = c->u.p;
287 const unsigned char *data = (const unsigned char *)_data;
288
289 if (len == 0)
290 return 1;
291
292 l = (c->Nl + (((SHA_LONG64) len) << 3)) & U64(0xffffffffffffffff);
293 if (l < c->Nl)
294 c->Nh++;
295 if (sizeof(len) >= 8)
296 c->Nh += (((SHA_LONG64) len) >> 61);
297 c->Nl = l;
298
299 if (c->num != 0) {
300 size_t n = sizeof(c->u) - c->num;
301
302 if (len < n) {
303 memcpy(p + c->num, data, len), c->num += (unsigned int)len;
304 return 1;
305 } else {
306 memcpy(p + c->num, data, n), c->num = 0;
307 len -= n, data += n;
308 sha512_block_data_order(c, p, 1);
309 }
310 }
311
312 if (len >= sizeof(c->u)) {
313 #ifndef SHA512_BLOCK_CAN_MANAGE_UNALIGNED_DATA
314 if ((size_t)data % sizeof(c->u.d[0]) != 0)
315 while (len >= sizeof(c->u))
316 memcpy(p, data, sizeof(c->u)),
317 sha512_block_data_order(c, p, 1),
318 len -= sizeof(c->u), data += sizeof(c->u);
319 else
320 #endif
321 sha512_block_data_order(c, data, len / sizeof(c->u)),
322 data += len, len %= sizeof(c->u), data -= len;
323 }
324
325 if (len != 0)
326 memcpy(p, data, len), c->num = (int)len;
327
328 return 1;
329 }
330
331 int SHA384_Update(SHA512_CTX *c, const void *data, size_t len)
332 {
333 return SHA512_Update(c, data, len);
334 }
335
336 void SHA512_Transform(SHA512_CTX *c, const unsigned char *data)
337 {
338 #ifndef SHA512_BLOCK_CAN_MANAGE_UNALIGNED_DATA
339 if ((size_t)data % sizeof(c->u.d[0]) != 0)
340 memcpy(c->u.p, data, sizeof(c->u.p)), data = c->u.p;
341 #endif
342 sha512_block_data_order(c, data, 1);
343 }
344
345 #if !defined(SHA512_ASM) || defined(INCLUDE_C_SHA512)
346 static const SHA_LONG64 K512[80] = {
347 U64(0x428a2f98d728ae22), U64(0x7137449123ef65cd),
348 U64(0xb5c0fbcfec4d3b2f), U64(0xe9b5dba58189dbbc),
349 U64(0x3956c25bf348b538), U64(0x59f111f1b605d019),
350 U64(0x923f82a4af194f9b), U64(0xab1c5ed5da6d8118),
351 U64(0xd807aa98a3030242), U64(0x12835b0145706fbe),
352 U64(0x243185be4ee4b28c), U64(0x550c7dc3d5ffb4e2),
353 U64(0x72be5d74f27b896f), U64(0x80deb1fe3b1696b1),
354 U64(0x9bdc06a725c71235), U64(0xc19bf174cf692694),
355 U64(0xe49b69c19ef14ad2), U64(0xefbe4786384f25e3),
356 U64(0x0fc19dc68b8cd5b5), U64(0x240ca1cc77ac9c65),
357 U64(0x2de92c6f592b0275), U64(0x4a7484aa6ea6e483),
358 U64(0x5cb0a9dcbd41fbd4), U64(0x76f988da831153b5),
359 U64(0x983e5152ee66dfab), U64(0xa831c66d2db43210),
360 U64(0xb00327c898fb213f), U64(0xbf597fc7beef0ee4),
361 U64(0xc6e00bf33da88fc2), U64(0xd5a79147930aa725),
362 U64(0x06ca6351e003826f), U64(0x142929670a0e6e70),
363 U64(0x27b70a8546d22ffc), U64(0x2e1b21385c26c926),
364 U64(0x4d2c6dfc5ac42aed), U64(0x53380d139d95b3df),
365 U64(0x650a73548baf63de), U64(0x766a0abb3c77b2a8),
366 U64(0x81c2c92e47edaee6), U64(0x92722c851482353b),
367 U64(0xa2bfe8a14cf10364), U64(0xa81a664bbc423001),
368 U64(0xc24b8b70d0f89791), U64(0xc76c51a30654be30),
369 U64(0xd192e819d6ef5218), U64(0xd69906245565a910),
370 U64(0xf40e35855771202a), U64(0x106aa07032bbd1b8),
371 U64(0x19a4c116b8d2d0c8), U64(0x1e376c085141ab53),
372 U64(0x2748774cdf8eeb99), U64(0x34b0bcb5e19b48a8),
373 U64(0x391c0cb3c5c95a63), U64(0x4ed8aa4ae3418acb),
374 U64(0x5b9cca4f7763e373), U64(0x682e6ff3d6b2b8a3),
375 U64(0x748f82ee5defb2fc), U64(0x78a5636f43172f60),
376 U64(0x84c87814a1f0ab72), U64(0x8cc702081a6439ec),
377 U64(0x90befffa23631e28), U64(0xa4506cebde82bde9),
378 U64(0xbef9a3f7b2c67915), U64(0xc67178f2e372532b),
379 U64(0xca273eceea26619c), U64(0xd186b8c721c0c207),
380 U64(0xeada7dd6cde0eb1e), U64(0xf57d4f7fee6ed178),
381 U64(0x06f067aa72176fba), U64(0x0a637dc5a2c898a6),
382 U64(0x113f9804bef90dae), U64(0x1b710b35131c471b),
383 U64(0x28db77f523047d84), U64(0x32caab7b40c72493),
384 U64(0x3c9ebe0a15c9bebc), U64(0x431d67c49c100d4c),
385 U64(0x4cc5d4becb3e42b6), U64(0x597f299cfc657e2a),
386 U64(0x5fcb6fab3ad6faec), U64(0x6c44198c4a475817)
387 };
388
389 # ifndef PEDANTIC
390 # if defined(__GNUC__) && __GNUC__>=2 && \
391 !defined(OPENSSL_NO_ASM) && !defined(OPENSSL_NO_INLINE_ASM)
392 # if defined(__x86_64) || defined(__x86_64__)
393 # define ROTR(a,n) ({ SHA_LONG64 ret; \
394 asm ("rorq %1,%0" \
395 : "=r"(ret) \
396 : "J"(n),"0"(a) \
397 : "cc"); ret; })
398 # if !defined(B_ENDIAN)
399 # define PULL64(x) ({ SHA_LONG64 ret=*((const SHA_LONG64 *)(&(x))); \
400 asm ("bswapq %0" \
401 : "=r"(ret) \
402 : "0"(ret)); ret; })
403 # endif
404 # elif (defined(__i386) || defined(__i386__)) && !defined(B_ENDIAN)
405 # if defined(I386_ONLY)
406 # define PULL64(x) ({ const unsigned int *p=(const unsigned int *)(&(x));\
407 unsigned int hi=p[0],lo=p[1]; \
408 asm("xchgb %%ah,%%al;xchgb %%dh,%%dl;"\
409 "roll $16,%%eax; roll $16,%%edx; "\
410 "xchgb %%ah,%%al;xchgb %%dh,%%dl;"\
411 : "=a"(lo),"=d"(hi) \
412 : "0"(lo),"1"(hi) : "cc"); \
413 ((SHA_LONG64)hi)<<32|lo; })
414 # else
415 # define PULL64(x) ({ const unsigned int *p=(const unsigned int *)(&(x));\
416 unsigned int hi=p[0],lo=p[1]; \
417 asm ("bswapl %0; bswapl %1;" \
418 : "=r"(lo),"=r"(hi) \
419 : "0"(lo),"1"(hi)); \
420 ((SHA_LONG64)hi)<<32|lo; })
421 # endif
422 # elif (defined(_ARCH_PPC) && defined(__64BIT__)) || defined(_ARCH_PPC64)
423 # define ROTR(a,n) ({ SHA_LONG64 ret; \
424 asm ("rotrdi %0,%1,%2" \
425 : "=r"(ret) \
426 : "r"(a),"K"(n)); ret; })
427 # elif defined(__aarch64__)
428 # define ROTR(a,n) ({ SHA_LONG64 ret; \
429 asm ("ror %0,%1,%2" \
430 : "=r"(ret) \
431 : "r"(a),"I"(n)); ret; })
432 # if defined(__BYTE_ORDER__) && defined(__ORDER_LITTLE_ENDIAN__) && \
433 __BYTE_ORDER__==__ORDER_LITTLE_ENDIAN__
434 # define PULL64(x) ({ SHA_LONG64 ret; \
435 asm ("rev %0,%1" \
436 : "=r"(ret) \
437 : "r"(*((const SHA_LONG64 *)(&(x))))); ret; })
438 # endif
439 # elif (defined(__riscv_zbkb) || defined(__riscv_zbb)) && __riscv_xlen == 32
440 # define PULL64(x) ({ SHA_LONG64 ret; \
441 unsigned int *r = (unsigned int *)(&(ret)); \
442 const unsigned int *p = (const unsigned int *)(&(x)); \
443 asm ("rev8 %0, %1" \
444 : "=r"(r[0]) \
445 : "r" (p[1])); \
446 asm ("rev8 %0, %1" \
447 : "=r"(r[1]) \
448 : "r" (p[0])); ret; })
449 # elif (defined(__riscv_zbkb) || defined(__riscv_zbb)) && __riscv_xlen == 64
450 # define PULL64(x) ({ SHA_LONG64 ret; \
451 asm ("rev8 %0, %1" \
452 : "=r"(ret) \
453 : "r"(x)); ret; })
454 # endif
455 # if defined(__riscv_zknh) && __riscv_xlen == 32
456 # define Sigma0(x) ({ SHA_LONG64 ret; unsigned int *r = (unsigned int *)(&(ret)); \
457 const unsigned int *p = (const unsigned int *)(&(x)); \
458 asm ("sha512sum0r %0, %1, %2" \
459 : "=r"(r[0]) \
460 : "r" (p[0]), "r" (p[1])); \
461 asm ("sha512sum0r %0, %2, %1" \
462 : "=r"(r[1]) \
463 : "r" (p[0]), "r" (p[1])); ret; })
464 # define Sigma1(x) ({ SHA_LONG64 ret; unsigned int *r = (unsigned int *)(&(ret)); \
465 const unsigned int *p = (const unsigned int *)(&(x)); \
466 asm ("sha512sum1r %0, %1, %2" \
467 : "=r"(r[0]) \
468 : "r" (p[0]), "r" (p[1])); \
469 asm ("sha512sum1r %0, %2, %1" \
470 : "=r"(r[1]) \
471 : "r" (p[0]), "r" (p[1])); ret; })
472 # define sigma0(x) ({ SHA_LONG64 ret; unsigned int *r = (unsigned int *)(&(ret)); \
473 const unsigned int *p = (const unsigned int *)(&(x)); \
474 asm ("sha512sig0l %0, %1, %2" \
475 : "=r"(r[0]) \
476 : "r" (p[0]), "r" (p[1])); \
477 asm ("sha512sig0h %0, %2, %1" \
478 : "=r"(r[1]) \
479 : "r" (p[0]), "r" (p[1])); ret; })
480 # define sigma1(x) ({ SHA_LONG64 ret; unsigned int *r = (unsigned int *)(&(ret)); \
481 const unsigned int *p = (const unsigned int *)(&(x)); \
482 asm ("sha512sig1l %0, %1, %2" \
483 : "=r"(r[0]) \
484 : "r" (p[0]), "r" (p[1])); \
485 asm ("sha512sig1h %0, %2, %1" \
486 : "=r"(r[1]) \
487 : "r" (p[0]), "r" (p[1])); ret; })
488 # elif defined(__riscv_zknh) && __riscv_xlen == 64
489 # define Sigma0(x) ({ SHA_LONG64 ret; \
490 asm ("sha512sum0 %0, %1" \
491 : "=r"(ret) \
492 : "r"(x)); ret; })
493 # define Sigma1(x) ({ SHA_LONG64 ret; \
494 asm ("sha512sum1 %0, %1" \
495 : "=r"(ret) \
496 : "r"(x)); ret; })
497 # define sigma0(x) ({ SHA_LONG64 ret; \
498 asm ("sha512sig0 %0, %1" \
499 : "=r"(ret) \
500 : "r"(x)); ret; })
501 # define sigma1(x) ({ SHA_LONG64 ret; \
502 asm ("sha512sig1 %0, %1" \
503 : "=r"(ret) \
504 : "r"(x)); ret; })
505 # endif
506 # if (defined(__riscv_zbt) || defined(__riscv_zpn)) && __riscv_xlen == 32
507 # define Ch(x,y,z) ({ SHA_LONG64 ret; unsigned int *r = (unsigned int *)(&(ret)); \
508 const unsigned int *xp = (const unsigned int *)(&(x)); \
509 const unsigned int *yp = (const unsigned int *)(&(y)); \
510 const unsigned int *zp = (const unsigned int *)(&(z)); \
511 asm (".insn r4 0x33, 1, 0x3, %0, %2, %1, %3\n\t" \
512 : "=r"(r[0]) \
513 : "r"(xp[0]), "r"(yp[0]), "r"(zp[0])); \
514 asm (".insn r4 0x33, 1, 0x3, %0, %2, %1, %3\n\t" \
515 : "=r"(r[1]) \
516 : "r"(xp[1]), "r"(yp[1]), "r"(zp[1])); ret; })
517 # define Maj(x,y,z) ({ SHA_LONG64 ret; unsigned int *r = (unsigned int *)(&(ret)); \
518 const unsigned int *xp = (const unsigned int *)(&(x)); \
519 const unsigned int *yp = (const unsigned int *)(&(y)); \
520 const unsigned int *zp = (const unsigned int *)(&(z)); \
521 asm (".insn r4 0x33, 1, 0x3, %0, %2, %1, %3\n\t" \
522 : "=r"(r[0]) \
523 : "r"(xp[0]^zp[0]), "r"(yp[0]), "r"(zp[0])); \
524 asm (".insn r4 0x33, 1, 0x3, %0, %2, %1, %3\n\t" \
525 : "=r"(r[1]) \
526 : "r"(xp[1]^zp[1]), "r"(yp[1]), "r"(zp[1])); ret; })
527 # elif (defined(__riscv_zbt) || defined(__riscv_zpn)) && __riscv_xlen == 64
528 # define Ch(x,y,z) ({ SHA_LONG64 ret; \
529 asm (".insn r4 0x33, 1, 0x3, %0, %2, %1, %3"\
530 : "=r"(ret) \
531 : "r"(x), "r"(y), "r"(z)); ret; })
532 # define Maj(x,y,z) ({ SHA_LONG64 ret; \
533 asm (".insn r4 0x33, 1, 0x3, %0, %2, %1, %3"\
534 : "=r"(ret) \
535 : "r"(x^z), "r"(y), "r"(x)); ret; })
536 # endif
537 # elif defined(_MSC_VER)
538 # if defined(_WIN64) /* applies to both IA-64 and AMD64 */
539 # pragma intrinsic(_rotr64)
540 # define ROTR(a,n) _rotr64((a),n)
541 # endif
542 # if defined(_M_IX86) && !defined(OPENSSL_NO_ASM) && \
543 !defined(OPENSSL_NO_INLINE_ASM)
544 # if defined(I386_ONLY)
545 static SHA_LONG64 __fastcall __pull64be(const void *x)
546 {
547 _asm mov edx,[ecx + 0]
548 _asm mov eax,[ecx + 4]
549 _asm xchg dh, dl
550 _asm xchg ah, al
551 _asm rol edx, 16
552 _asm rol eax, 16
553 _asm xchg dh, dl
554 _asm xchg ah, al
555 }
556 # else
557 static SHA_LONG64 __fastcall __pull64be(const void *x)
558 {
559 _asm mov edx,[ecx + 0]
560 _asm mov eax,[ecx + 4]
561 _asm bswap edx
562 _asm bswap eax
563 }
564 # endif
565 # define PULL64(x) __pull64be(&(x))
566 # endif
567 # endif
568 # endif
569 # ifndef PULL64
570 # define B(x,j) (((SHA_LONG64)(*(((const unsigned char *)(&x))+j)))<<((7-j)*8))
571 # define PULL64(x) (B(x,0)|B(x,1)|B(x,2)|B(x,3)|B(x,4)|B(x,5)|B(x,6)|B(x,7))
572 # endif
573 # ifndef ROTR
574 # define ROTR(x,s) (((x)>>s) | (x)<<(64-s))
575 # endif
576 # ifndef Sigma0
577 # define Sigma0(x) (ROTR((x),28) ^ ROTR((x),34) ^ ROTR((x),39))
578 # endif
579 # ifndef Sigma1
580 # define Sigma1(x) (ROTR((x),14) ^ ROTR((x),18) ^ ROTR((x),41))
581 # endif
582 # ifndef sigma0
583 # define sigma0(x) (ROTR((x),1) ^ ROTR((x),8) ^ ((x)>>7))
584 # endif
585 # ifndef sigma1
586 # define sigma1(x) (ROTR((x),19) ^ ROTR((x),61) ^ ((x)>>6))
587 # endif
588 # ifndef Ch
589 # define Ch(x,y,z) (((x) & (y)) ^ ((~(x)) & (z)))
590 # endif
591 # ifndef Maj
592 # define Maj(x,y,z) (((x) & (y)) ^ ((x) & (z)) ^ ((y) & (z)))
593 # endif
594
595 # if defined(__i386) || defined(__i386__) || defined(_M_IX86)
596 /*
597 * This code should give better results on 32-bit CPU with less than
598 * ~24 registers, both size and performance wise...
599 */
600
601 static void sha512_block_data_order(SHA512_CTX *ctx, const void *in,
602 size_t num)
603 {
604 const SHA_LONG64 *W = in;
605 SHA_LONG64 A, E, T;
606 SHA_LONG64 X[9 + 80], *F;
607 int i;
608
609 while (num--) {
610
611 F = X + 80;
612 A = ctx->h[0];
613 F[1] = ctx->h[1];
614 F[2] = ctx->h[2];
615 F[3] = ctx->h[3];
616 E = ctx->h[4];
617 F[5] = ctx->h[5];
618 F[6] = ctx->h[6];
619 F[7] = ctx->h[7];
620
621 for (i = 0; i < 16; i++, F--) {
622 # ifdef B_ENDIAN
623 T = W[i];
624 # else
625 T = PULL64(W[i]);
626 # endif
627 F[0] = A;
628 F[4] = E;
629 F[8] = T;
630 T += F[7] + Sigma1(E) + Ch(E, F[5], F[6]) + K512[i];
631 E = F[3] + T;
632 A = T + Sigma0(A) + Maj(A, F[1], F[2]);
633 }
634
635 for (; i < 80; i++, F--) {
636 T = sigma0(F[8 + 16 - 1]);
637 T += sigma1(F[8 + 16 - 14]);
638 T += F[8 + 16] + F[8 + 16 - 9];
639
640 F[0] = A;
641 F[4] = E;
642 F[8] = T;
643 T += F[7] + Sigma1(E) + Ch(E, F[5], F[6]) + K512[i];
644 E = F[3] + T;
645 A = T + Sigma0(A) + Maj(A, F[1], F[2]);
646 }
647
648 ctx->h[0] += A;
649 ctx->h[1] += F[1];
650 ctx->h[2] += F[2];
651 ctx->h[3] += F[3];
652 ctx->h[4] += E;
653 ctx->h[5] += F[5];
654 ctx->h[6] += F[6];
655 ctx->h[7] += F[7];
656
657 W += SHA_LBLOCK;
658 }
659 }
660
661 # elif defined(OPENSSL_SMALL_FOOTPRINT)
662
663 static void sha512_block_data_order(SHA512_CTX *ctx, const void *in,
664 size_t num)
665 {
666 const SHA_LONG64 *W = in;
667 SHA_LONG64 a, b, c, d, e, f, g, h, s0, s1, T1, T2;
668 SHA_LONG64 X[16];
669 int i;
670
671 while (num--) {
672
673 a = ctx->h[0];
674 b = ctx->h[1];
675 c = ctx->h[2];
676 d = ctx->h[3];
677 e = ctx->h[4];
678 f = ctx->h[5];
679 g = ctx->h[6];
680 h = ctx->h[7];
681
682 for (i = 0; i < 16; i++) {
683 # ifdef B_ENDIAN
684 T1 = X[i] = W[i];
685 # else
686 T1 = X[i] = PULL64(W[i]);
687 # endif
688 T1 += h + Sigma1(e) + Ch(e, f, g) + K512[i];
689 T2 = Sigma0(a) + Maj(a, b, c);
690 h = g;
691 g = f;
692 f = e;
693 e = d + T1;
694 d = c;
695 c = b;
696 b = a;
697 a = T1 + T2;
698 }
699
700 for (; i < 80; i++) {
701 s0 = X[(i + 1) & 0x0f];
702 s0 = sigma0(s0);
703 s1 = X[(i + 14) & 0x0f];
704 s1 = sigma1(s1);
705
706 T1 = X[i & 0xf] += s0 + s1 + X[(i + 9) & 0xf];
707 T1 += h + Sigma1(e) + Ch(e, f, g) + K512[i];
708 T2 = Sigma0(a) + Maj(a, b, c);
709 h = g;
710 g = f;
711 f = e;
712 e = d + T1;
713 d = c;
714 c = b;
715 b = a;
716 a = T1 + T2;
717 }
718
719 ctx->h[0] += a;
720 ctx->h[1] += b;
721 ctx->h[2] += c;
722 ctx->h[3] += d;
723 ctx->h[4] += e;
724 ctx->h[5] += f;
725 ctx->h[6] += g;
726 ctx->h[7] += h;
727
728 W += SHA_LBLOCK;
729 }
730 }
731
732 # else
733 # define ROUND_00_15(i,a,b,c,d,e,f,g,h) do { \
734 T1 += h + Sigma1(e) + Ch(e,f,g) + K512[i]; \
735 h = Sigma0(a) + Maj(a,b,c); \
736 d += T1; h += T1; } while (0)
737
738 # define ROUND_16_80(i,j,a,b,c,d,e,f,g,h,X) do { \
739 s0 = X[(j+1)&0x0f]; s0 = sigma0(s0); \
740 s1 = X[(j+14)&0x0f]; s1 = sigma1(s1); \
741 T1 = X[(j)&0x0f] += s0 + s1 + X[(j+9)&0x0f]; \
742 ROUND_00_15(i+j,a,b,c,d,e,f,g,h); } while (0)
743
744 #ifdef INCLUDE_C_SHA512
745 void sha512_block_data_order_c(SHA512_CTX *ctx, const void *in, size_t num)
746 #else
747 static void sha512_block_data_order(SHA512_CTX *ctx, const void *in,
748 size_t num)
749 #endif
750 {
751 const SHA_LONG64 *W = in;
752 SHA_LONG64 a, b, c, d, e, f, g, h, s0, s1, T1;
753 SHA_LONG64 X[16];
754 int i;
755
756 while (num--) {
757
758 a = ctx->h[0];
759 b = ctx->h[1];
760 c = ctx->h[2];
761 d = ctx->h[3];
762 e = ctx->h[4];
763 f = ctx->h[5];
764 g = ctx->h[6];
765 h = ctx->h[7];
766
767 # ifdef B_ENDIAN
768 T1 = X[0] = W[0];
769 ROUND_00_15(0, a, b, c, d, e, f, g, h);
770 T1 = X[1] = W[1];
771 ROUND_00_15(1, h, a, b, c, d, e, f, g);
772 T1 = X[2] = W[2];
773 ROUND_00_15(2, g, h, a, b, c, d, e, f);
774 T1 = X[3] = W[3];
775 ROUND_00_15(3, f, g, h, a, b, c, d, e);
776 T1 = X[4] = W[4];
777 ROUND_00_15(4, e, f, g, h, a, b, c, d);
778 T1 = X[5] = W[5];
779 ROUND_00_15(5, d, e, f, g, h, a, b, c);
780 T1 = X[6] = W[6];
781 ROUND_00_15(6, c, d, e, f, g, h, a, b);
782 T1 = X[7] = W[7];
783 ROUND_00_15(7, b, c, d, e, f, g, h, a);
784 T1 = X[8] = W[8];
785 ROUND_00_15(8, a, b, c, d, e, f, g, h);
786 T1 = X[9] = W[9];
787 ROUND_00_15(9, h, a, b, c, d, e, f, g);
788 T1 = X[10] = W[10];
789 ROUND_00_15(10, g, h, a, b, c, d, e, f);
790 T1 = X[11] = W[11];
791 ROUND_00_15(11, f, g, h, a, b, c, d, e);
792 T1 = X[12] = W[12];
793 ROUND_00_15(12, e, f, g, h, a, b, c, d);
794 T1 = X[13] = W[13];
795 ROUND_00_15(13, d, e, f, g, h, a, b, c);
796 T1 = X[14] = W[14];
797 ROUND_00_15(14, c, d, e, f, g, h, a, b);
798 T1 = X[15] = W[15];
799 ROUND_00_15(15, b, c, d, e, f, g, h, a);
800 # else
801 T1 = X[0] = PULL64(W[0]);
802 ROUND_00_15(0, a, b, c, d, e, f, g, h);
803 T1 = X[1] = PULL64(W[1]);
804 ROUND_00_15(1, h, a, b, c, d, e, f, g);
805 T1 = X[2] = PULL64(W[2]);
806 ROUND_00_15(2, g, h, a, b, c, d, e, f);
807 T1 = X[3] = PULL64(W[3]);
808 ROUND_00_15(3, f, g, h, a, b, c, d, e);
809 T1 = X[4] = PULL64(W[4]);
810 ROUND_00_15(4, e, f, g, h, a, b, c, d);
811 T1 = X[5] = PULL64(W[5]);
812 ROUND_00_15(5, d, e, f, g, h, a, b, c);
813 T1 = X[6] = PULL64(W[6]);
814 ROUND_00_15(6, c, d, e, f, g, h, a, b);
815 T1 = X[7] = PULL64(W[7]);
816 ROUND_00_15(7, b, c, d, e, f, g, h, a);
817 T1 = X[8] = PULL64(W[8]);
818 ROUND_00_15(8, a, b, c, d, e, f, g, h);
819 T1 = X[9] = PULL64(W[9]);
820 ROUND_00_15(9, h, a, b, c, d, e, f, g);
821 T1 = X[10] = PULL64(W[10]);
822 ROUND_00_15(10, g, h, a, b, c, d, e, f);
823 T1 = X[11] = PULL64(W[11]);
824 ROUND_00_15(11, f, g, h, a, b, c, d, e);
825 T1 = X[12] = PULL64(W[12]);
826 ROUND_00_15(12, e, f, g, h, a, b, c, d);
827 T1 = X[13] = PULL64(W[13]);
828 ROUND_00_15(13, d, e, f, g, h, a, b, c);
829 T1 = X[14] = PULL64(W[14]);
830 ROUND_00_15(14, c, d, e, f, g, h, a, b);
831 T1 = X[15] = PULL64(W[15]);
832 ROUND_00_15(15, b, c, d, e, f, g, h, a);
833 # endif
834
835 for (i = 16; i < 80; i += 16) {
836 ROUND_16_80(i, 0, a, b, c, d, e, f, g, h, X);
837 ROUND_16_80(i, 1, h, a, b, c, d, e, f, g, X);
838 ROUND_16_80(i, 2, g, h, a, b, c, d, e, f, X);
839 ROUND_16_80(i, 3, f, g, h, a, b, c, d, e, X);
840 ROUND_16_80(i, 4, e, f, g, h, a, b, c, d, X);
841 ROUND_16_80(i, 5, d, e, f, g, h, a, b, c, X);
842 ROUND_16_80(i, 6, c, d, e, f, g, h, a, b, X);
843 ROUND_16_80(i, 7, b, c, d, e, f, g, h, a, X);
844 ROUND_16_80(i, 8, a, b, c, d, e, f, g, h, X);
845 ROUND_16_80(i, 9, h, a, b, c, d, e, f, g, X);
846 ROUND_16_80(i, 10, g, h, a, b, c, d, e, f, X);
847 ROUND_16_80(i, 11, f, g, h, a, b, c, d, e, X);
848 ROUND_16_80(i, 12, e, f, g, h, a, b, c, d, X);
849 ROUND_16_80(i, 13, d, e, f, g, h, a, b, c, X);
850 ROUND_16_80(i, 14, c, d, e, f, g, h, a, b, X);
851 ROUND_16_80(i, 15, b, c, d, e, f, g, h, a, X);
852 }
853
854 ctx->h[0] += a;
855 ctx->h[1] += b;
856 ctx->h[2] += c;
857 ctx->h[3] += d;
858 ctx->h[4] += e;
859 ctx->h[5] += f;
860 ctx->h[6] += g;
861 ctx->h[7] += h;
862
863 W += SHA_LBLOCK;
864 }
865 }
866
867 # endif
868
869 #endif /* SHA512_ASM */
A mirror of the official openssl repository