]>
git.proxmox.com Git - mirror_ubuntu-bionic-kernel.git/blob - zfs/module/icp/algs/edonr/edonr.c
6 * The contents of this file are subject to the terms of the
7 * Common Development and Distribution License (the "License").
8 * You may not use this file except in compliance with the License.
10 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
11 * or http://opensource.org/licenses/CDDL-1.0.
12 * See the License for the specific language governing permissions
13 * and limitations under the License.
15 * When distributing Covered Code, include this CDDL HEADER in each
16 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
17 * If applicable, add the following below this CDDL HEADER, with the
18 * fields enclosed by brackets "[]" replaced with your own identifying
19 * information: Portions Copyright [yyyy] [name of copyright owner]
23 * Copyright (C) 2009, 2010, Jorn Amundsen <jorn.amundsen@ntnu.no>
24 * Tweaked Edon-R implementation for SUPERCOP, based on NIST API.
26 * $Id: edonr.c 517 2013-02-17 20:34:39Z joern $
29 * Portions copyright (c) 2013, Saso Kiselkov, All rights reserved
32 /* determine where we can get bcopy/bzero declarations */
34 #include <sys/systm.h>
38 #include <sys/edonr.h>
39 #include <sys/debug.h>
41 /* big endian support, provides no-op's if run on little endian hosts */
42 #include "edonr_byteorder.h"
44 #define hashState224(x) ((x)->pipe->p256)
45 #define hashState256(x) ((x)->pipe->p256)
46 #define hashState384(x) ((x)->pipe->p512)
47 #define hashState512(x) ((x)->pipe->p512)
49 /* shift and rotate shortcuts */
50 #define shl(x, n) ((x) << n)
51 #define shr(x, n) ((x) >> n)
53 #define rotl32(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
54 #define rotr32(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
56 #define rotl64(x, n) (((x) << (n)) | ((x) >> (64 - (n))))
57 #define rotr64(x, n) (((x) >> (n)) | ((x) << (64 - (n))))
59 #if !defined(__C99_RESTRICT)
60 #define restrict /* restrict */
63 #define EDONR_VALID_HASHBITLEN(x) \
64 ((x) == 512 || (x) == 384 || (x) == 256 || (x) == 224)
66 /* EdonR224 initial double chaining pipe */
67 static const uint32_t i224p2
[16] = {
68 0x00010203ul
, 0x04050607ul
, 0x08090a0bul
, 0x0c0d0e0ful
,
69 0x10111213ul
, 0x14151617ul
, 0x18191a1bul
, 0x1c1d1e1ful
,
70 0x20212223ul
, 0x24252627ul
, 0x28292a2bul
, 0x2c2d2e2ful
,
71 0x30313233ul
, 0x34353637ul
, 0x38393a3bul
, 0x3c3d3e3ful
,
74 /* EdonR256 initial double chaining pipe */
75 static const uint32_t i256p2
[16] = {
76 0x40414243ul
, 0x44454647ul
, 0x48494a4bul
, 0x4c4d4e4ful
,
77 0x50515253ul
, 0x54555657ul
, 0x58595a5bul
, 0x5c5d5e5ful
,
78 0x60616263ul
, 0x64656667ul
, 0x68696a6bul
, 0x6c6d6e6ful
,
79 0x70717273ul
, 0x74757677ul
, 0x78797a7bul
, 0x7c7d7e7ful
,
82 /* EdonR384 initial double chaining pipe */
83 static const uint64_t i384p2
[16] = {
84 0x0001020304050607ull
, 0x08090a0b0c0d0e0full
,
85 0x1011121314151617ull
, 0x18191a1b1c1d1e1full
,
86 0x2021222324252627ull
, 0x28292a2b2c2d2e2full
,
87 0x3031323334353637ull
, 0x38393a3b3c3d3e3full
,
88 0x4041424344454647ull
, 0x48494a4b4c4d4e4full
,
89 0x5051525354555657ull
, 0x58595a5b5c5d5e5full
,
90 0x6061626364656667ull
, 0x68696a6b6c6d6e6full
,
91 0x7071727374757677ull
, 0x78797a7b7c7d7e7full
94 /* EdonR512 initial double chaining pipe */
95 static const uint64_t i512p2
[16] = {
96 0x8081828384858687ull
, 0x88898a8b8c8d8e8full
,
97 0x9091929394959697ull
, 0x98999a9b9c9d9e9full
,
98 0xa0a1a2a3a4a5a6a7ull
, 0xa8a9aaabacadaeafull
,
99 0xb0b1b2b3b4b5b6b7ull
, 0xb8b9babbbcbdbebfull
,
100 0xc0c1c2c3c4c5c6c7ull
, 0xc8c9cacbcccdcecfull
,
101 0xd0d1d2d3d4d5d6d7ull
, 0xd8d9dadbdcdddedfull
,
102 0xe0e1e2e3e4e5e6e7ull
, 0xe8e9eaebecedeeefull
,
103 0xf0f1f2f3f4f5f6f7ull
, 0xf8f9fafbfcfdfeffull
117 #define LS1_256(c, x0, x1, x2, x3, x4, x5, x6, x7) \
119 uint32_t x04, x17, x23, x56, x07, x26; \
120 x04 = x0+x4, x17 = x1+x7, x07 = x04+x17; \
122 s1 = rotl32(x07 + x3, 4); \
123 s2 = rotl32(x07 + x6, 8); \
125 s5 = rotl32(x04 + x23 + x5, 22); \
127 s6 = rotl32(x17 + x56 + x0, 24); \
129 s3 = rotl32(x26 + x7, 13); \
130 s4 = rotl32(x26 + x1, 17); \
131 s7 = rotl32(x26 + x4, 29); \
134 #define LS1_512(c, x0, x1, x2, x3, x4, x5, x6, x7) \
136 uint64_t x04, x17, x23, x56, x07, x26; \
137 x04 = x0+x4, x17 = x1+x7, x07 = x04+x17; \
139 s1 = rotl64(x07 + x3, 5); \
140 s2 = rotl64(x07 + x6, 15); \
142 s5 = rotl64(x04 + x23 + x5, 40); \
144 s6 = rotl64(x17 + x56 + x0, 50); \
146 s3 = rotl64(x26 + x7, 22); \
147 s4 = rotl64(x26 + x1, 31); \
148 s7 = rotl64(x26 + x4, 59); \
152 * Second Orthogonal Latin Square
162 #define LS2_256(c, y0, y1, y2, y3, y4, y5, y6, y7) \
164 uint32_t y01, y25, y34, y67, y04, y05, y27, y37; \
165 y01 = y0+y1, y25 = y2+y5, y05 = y01+y25; \
166 t0 = ~c + y05 + y7; \
167 t2 = rotl32(y05 + y3, 9); \
168 y34 = y3+y4, y04 = y01+y34; \
169 t1 = rotl32(y04 + y6, 5); \
170 t4 = rotl32(y04 + y5, 15); \
171 y67 = y6+y7, y37 = y34+y67; \
172 t3 = rotl32(y37 + y2, 11); \
173 t7 = rotl32(y37 + y0, 27); \
175 t5 = rotl32(y27 + y4, 20); \
176 t6 = rotl32(y27 + y1, 25); \
179 #define LS2_512(c, y0, y1, y2, y3, y4, y5, y6, y7) \
181 uint64_t y01, y25, y34, y67, y04, y05, y27, y37; \
182 y01 = y0+y1, y25 = y2+y5, y05 = y01+y25; \
183 t0 = ~c + y05 + y7; \
184 t2 = rotl64(y05 + y3, 19); \
185 y34 = y3+y4, y04 = y01+y34; \
186 t1 = rotl64(y04 + y6, 10); \
187 t4 = rotl64(y04 + y5, 36); \
188 y67 = y6+y7, y37 = y34+y67; \
189 t3 = rotl64(y37 + y2, 29); \
190 t7 = rotl64(y37 + y0, 55); \
192 t5 = rotl64(y27 + y4, 44); \
193 t6 = rotl64(y27 + y1, 48); \
196 #define quasi_exform256(r0, r1, r2, r3, r4, r5, r6, r7) \
198 uint32_t s04, s17, s23, s56, t01, t25, t34, t67; \
199 s04 = s0 ^ s4, t01 = t0 ^ t1; \
200 r0 = (s04 ^ s1) + (t01 ^ t5); \
202 r1 = (s04 ^ s7) + (t2 ^ t67); \
204 r7 = (s23 ^ s5) + (t4 ^ t67); \
206 r3 = (s23 ^ s4) + (t0 ^ t34); \
208 r5 = (s3 ^ s56) + (t34 ^ t6); \
210 r6 = (s2 ^ s56) + (t25 ^ t7); \
212 r4 = (s0 ^ s17) + (t1 ^ t25); \
213 r2 = (s17 ^ s6) + (t01 ^ t3); \
216 #define quasi_exform512(r0, r1, r2, r3, r4, r5, r6, r7) \
218 uint64_t s04, s17, s23, s56, t01, t25, t34, t67; \
219 s04 = s0 ^ s4, t01 = t0 ^ t1; \
220 r0 = (s04 ^ s1) + (t01 ^ t5); \
222 r1 = (s04 ^ s7) + (t2 ^ t67); \
224 r7 = (s23 ^ s5) + (t4 ^ t67); \
226 r3 = (s23 ^ s4) + (t0 ^ t34); \
228 r5 = (s3 ^ s56) + (t34 ^ t6); \
230 r6 = (s2 ^ s56) + (t25 ^ t7); \
232 r4 = (s0 ^ s17) + (t1 ^ t25); \
233 r2 = (s17 ^ s6) + (t01 ^ t3); \
237 Q256(size_t bitlen
, const uint32_t *data
, uint32_t *restrict p
)
241 for (bl
= bitlen
; bl
>= EdonR256_BLOCK_BITSIZE
;
242 bl
-= EdonR256_BLOCK_BITSIZE
, data
+= 16) {
243 uint32_t s0
, s1
, s2
, s3
, s4
, s5
, s6
, s7
, t0
, t1
, t2
, t3
, t4
,
245 uint32_t p0
, p1
, p2
, p3
, p4
, p5
, p6
, p7
, q0
, q1
, q2
, q3
, q4
,
247 const uint32_t defix
= 0xaaaaaaaa;
248 #if defined(MACHINE_IS_BIG_ENDIAN)
249 uint32_t swp0
, swp1
, swp2
, swp3
, swp4
, swp5
, swp6
, swp7
, swp8
,
250 swp9
, swp10
, swp11
, swp12
, swp13
, swp14
, swp15
;
251 #define d(j) swp ## j
252 #define s32(j) ld_swap32((uint32_t *)data + j, swp ## j)
257 /* First row of quasigroup e-transformations */
258 #if defined(MACHINE_IS_BIG_ENDIAN)
268 LS1_256(defix
, d(15), d(14), d(13), d(12), d(11), d(10), d(9),
270 #if defined(MACHINE_IS_BIG_ENDIAN)
281 LS2_256(defix
, d(0), d(1), d(2), d(3), d(4), d(5), d(6), d(7));
282 quasi_exform256(p0
, p1
, p2
, p3
, p4
, p5
, p6
, p7
);
284 LS1_256(defix
, p0
, p1
, p2
, p3
, p4
, p5
, p6
, p7
);
285 LS2_256(defix
, d(8), d(9), d(10), d(11), d(12), d(13), d(14),
287 quasi_exform256(q0
, q1
, q2
, q3
, q4
, q5
, q6
, q7
);
289 /* Second row of quasigroup e-transformations */
290 LS1_256(defix
, p
[8], p
[9], p
[10], p
[11], p
[12], p
[13], p
[14],
292 LS2_256(defix
, p0
, p1
, p2
, p3
, p4
, p5
, p6
, p7
);
293 quasi_exform256(p0
, p1
, p2
, p3
, p4
, p5
, p6
, p7
);
295 LS1_256(defix
, p0
, p1
, p2
, p3
, p4
, p5
, p6
, p7
);
296 LS2_256(defix
, q0
, q1
, q2
, q3
, q4
, q5
, q6
, q7
);
297 quasi_exform256(q0
, q1
, q2
, q3
, q4
, q5
, q6
, q7
);
299 /* Third row of quasigroup e-transformations */
300 LS1_256(defix
, p0
, p1
, p2
, p3
, p4
, p5
, p6
, p7
);
301 LS2_256(defix
, p
[0], p
[1], p
[2], p
[3], p
[4], p
[5], p
[6], p
[7]);
302 quasi_exform256(p0
, p1
, p2
, p3
, p4
, p5
, p6
, p7
);
304 LS1_256(defix
, q0
, q1
, q2
, q3
, q4
, q5
, q6
, q7
);
305 LS2_256(defix
, p0
, p1
, p2
, p3
, p4
, p5
, p6
, p7
);
306 quasi_exform256(q0
, q1
, q2
, q3
, q4
, q5
, q6
, q7
);
308 /* Fourth row of quasigroup e-transformations */
309 LS1_256(defix
, d(7), d(6), d(5), d(4), d(3), d(2), d(1), d(0));
310 LS2_256(defix
, p0
, p1
, p2
, p3
, p4
, p5
, p6
, p7
);
311 quasi_exform256(p0
, p1
, p2
, p3
, p4
, p5
, p6
, p7
);
313 LS1_256(defix
, p0
, p1
, p2
, p3
, p4
, p5
, p6
, p7
);
314 LS2_256(defix
, q0
, q1
, q2
, q3
, q4
, q5
, q6
, q7
);
315 quasi_exform256(q0
, q1
, q2
, q3
, q4
, q5
, q6
, q7
);
317 /* Edon-R tweak on the original SHA-3 Edon-R submission. */
337 return (bitlen
- bl
);
341 * Why is this #pragma here?
343 * Checksum functions like this one can go over the stack frame size check
344 * Linux imposes on 32-bit platforms (-Wframe-larger-than=1024). We can
345 * safely ignore the compiler error since we know that in ZoL, that
346 * the function will be called from a worker thread that won't be using
347 * much stack. The only function that goes over the 1k limit is Q512(),
348 * which only goes over it by a hair (1248 bytes on ARM32).
350 #include <sys/isa_defs.h> /* for _ILP32 */
351 #ifdef _ILP32 /* We're 32-bit, assume small stack frames */
352 #pragma GCC diagnostic ignored "-Wframe-larger-than="
355 #if defined(__IBMC__) && defined(_AIX) && defined(__64BIT__)
360 Q512(size_t bitlen
, const uint64_t *data
, uint64_t *restrict p
)
364 for (bl
= bitlen
; bl
>= EdonR512_BLOCK_BITSIZE
;
365 bl
-= EdonR512_BLOCK_BITSIZE
, data
+= 16) {
366 uint64_t s0
, s1
, s2
, s3
, s4
, s5
, s6
, s7
, t0
, t1
, t2
, t3
, t4
,
368 uint64_t p0
, p1
, p2
, p3
, p4
, p5
, p6
, p7
, q0
, q1
, q2
, q3
, q4
,
370 const uint64_t defix
= 0xaaaaaaaaaaaaaaaaull
;
371 #if defined(MACHINE_IS_BIG_ENDIAN)
372 uint64_t swp0
, swp1
, swp2
, swp3
, swp4
, swp5
, swp6
, swp7
, swp8
,
373 swp9
, swp10
, swp11
, swp12
, swp13
, swp14
, swp15
;
375 #define s64(j) ld_swap64((uint64_t *)data+j, swp##j)
380 /* First row of quasigroup e-transformations */
381 #if defined(MACHINE_IS_BIG_ENDIAN)
391 LS1_512(defix
, d(15), d(14), d(13), d(12), d(11), d(10), d(9),
393 #if defined(MACHINE_IS_BIG_ENDIAN)
404 LS2_512(defix
, d(0), d(1), d(2), d(3), d(4), d(5), d(6), d(7));
405 quasi_exform512(p0
, p1
, p2
, p3
, p4
, p5
, p6
, p7
);
407 LS1_512(defix
, p0
, p1
, p2
, p3
, p4
, p5
, p6
, p7
);
408 LS2_512(defix
, d(8), d(9), d(10), d(11), d(12), d(13), d(14),
410 quasi_exform512(q0
, q1
, q2
, q3
, q4
, q5
, q6
, q7
);
412 /* Second row of quasigroup e-transformations */
413 LS1_512(defix
, p
[8], p
[9], p
[10], p
[11], p
[12], p
[13], p
[14],
415 LS2_512(defix
, p0
, p1
, p2
, p3
, p4
, p5
, p6
, p7
);
416 quasi_exform512(p0
, p1
, p2
, p3
, p4
, p5
, p6
, p7
);
418 LS1_512(defix
, p0
, p1
, p2
, p3
, p4
, p5
, p6
, p7
);
419 LS2_512(defix
, q0
, q1
, q2
, q3
, q4
, q5
, q6
, q7
);
420 quasi_exform512(q0
, q1
, q2
, q3
, q4
, q5
, q6
, q7
);
422 /* Third row of quasigroup e-transformations */
423 LS1_512(defix
, p0
, p1
, p2
, p3
, p4
, p5
, p6
, p7
);
424 LS2_512(defix
, p
[0], p
[1], p
[2], p
[3], p
[4], p
[5], p
[6], p
[7]);
425 quasi_exform512(p0
, p1
, p2
, p3
, p4
, p5
, p6
, p7
);
427 LS1_512(defix
, q0
, q1
, q2
, q3
, q4
, q5
, q6
, q7
);
428 LS2_512(defix
, p0
, p1
, p2
, p3
, p4
, p5
, p6
, p7
);
429 quasi_exform512(q0
, q1
, q2
, q3
, q4
, q5
, q6
, q7
);
431 /* Fourth row of quasigroup e-transformations */
432 LS1_512(defix
, d(7), d(6), d(5), d(4), d(3), d(2), d(1), d(0));
433 LS2_512(defix
, p0
, p1
, p2
, p3
, p4
, p5
, p6
, p7
);
434 quasi_exform512(p0
, p1
, p2
, p3
, p4
, p5
, p6
, p7
);
436 LS1_512(defix
, p0
, p1
, p2
, p3
, p4
, p5
, p6
, p7
);
437 LS2_512(defix
, q0
, q1
, q2
, q3
, q4
, q5
, q6
, q7
);
438 quasi_exform512(q0
, q1
, q2
, q3
, q4
, q5
, q6
, q7
);
440 /* Edon-R tweak on the original SHA-3 Edon-R submission. */
460 return (bitlen
- bl
);
464 EdonRInit(EdonRState
*state
, size_t hashbitlen
)
466 ASSERT(EDONR_VALID_HASHBITLEN(hashbitlen
));
467 switch (hashbitlen
) {
469 state
->hashbitlen
= 224;
470 state
->bits_processed
= 0;
471 state
->unprocessed_bits
= 0;
472 bcopy(i224p2
, hashState224(state
)->DoublePipe
,
473 16 * sizeof (uint32_t));
477 state
->hashbitlen
= 256;
478 state
->bits_processed
= 0;
479 state
->unprocessed_bits
= 0;
480 bcopy(i256p2
, hashState256(state
)->DoublePipe
,
481 16 * sizeof (uint32_t));
485 state
->hashbitlen
= 384;
486 state
->bits_processed
= 0;
487 state
->unprocessed_bits
= 0;
488 bcopy(i384p2
, hashState384(state
)->DoublePipe
,
489 16 * sizeof (uint64_t));
493 state
->hashbitlen
= 512;
494 state
->bits_processed
= 0;
495 state
->unprocessed_bits
= 0;
496 bcopy(i512p2
, hashState224(state
)->DoublePipe
,
497 16 * sizeof (uint64_t));
504 EdonRUpdate(EdonRState
*state
, const uint8_t *data
, size_t databitlen
)
509 size_t bits_processed
;
511 ASSERT(EDONR_VALID_HASHBITLEN(state
->hashbitlen
));
512 switch (state
->hashbitlen
) {
515 if (state
->unprocessed_bits
> 0) {
516 /* LastBytes = databitlen / 8 */
517 int LastBytes
= (int)databitlen
>> 3;
519 ASSERT(state
->unprocessed_bits
+ databitlen
<=
520 EdonR256_BLOCK_SIZE
* 8);
522 bcopy(data
, hashState256(state
)->LastPart
523 + (state
->unprocessed_bits
>> 3), LastBytes
);
524 state
->unprocessed_bits
+= (int)databitlen
;
525 databitlen
= state
->unprocessed_bits
;
526 /* LINTED E_BAD_PTR_CAST_ALIGN */
527 data32
= (uint32_t *)hashState256(state
)->LastPart
;
529 /* LINTED E_BAD_PTR_CAST_ALIGN */
530 data32
= (uint32_t *)data
;
532 bits_processed
= Q256(databitlen
, data32
,
533 hashState256(state
)->DoublePipe
);
534 state
->bits_processed
+= bits_processed
;
535 databitlen
-= bits_processed
;
536 state
->unprocessed_bits
= (int)databitlen
;
537 if (databitlen
> 0) {
538 /* LastBytes = Ceil(databitlen / 8) */
540 ((~(((-(int)databitlen
) >> 3) & 0x01ff)) +
543 data32
+= bits_processed
>> 5; /* byte size update */
544 bcopy(data32
, hashState256(state
)->LastPart
, LastBytes
);
550 if (state
->unprocessed_bits
> 0) {
551 /* LastBytes = databitlen / 8 */
552 int LastBytes
= (int)databitlen
>> 3;
554 ASSERT(state
->unprocessed_bits
+ databitlen
<=
555 EdonR512_BLOCK_SIZE
* 8);
557 bcopy(data
, hashState512(state
)->LastPart
558 + (state
->unprocessed_bits
>> 3), LastBytes
);
559 state
->unprocessed_bits
+= (int)databitlen
;
560 databitlen
= state
->unprocessed_bits
;
561 /* LINTED E_BAD_PTR_CAST_ALIGN */
562 data64
= (uint64_t *)hashState512(state
)->LastPart
;
564 /* LINTED E_BAD_PTR_CAST_ALIGN */
565 data64
= (uint64_t *)data
;
567 bits_processed
= Q512(databitlen
, data64
,
568 hashState512(state
)->DoublePipe
);
569 state
->bits_processed
+= bits_processed
;
570 databitlen
-= bits_processed
;
571 state
->unprocessed_bits
= (int)databitlen
;
572 if (databitlen
> 0) {
573 /* LastBytes = Ceil(databitlen / 8) */
575 ((~(((-(int)databitlen
) >> 3) & 0x03ff)) +
578 data64
+= bits_processed
>> 6; /* byte size update */
579 bcopy(data64
, hashState512(state
)->LastPart
, LastBytes
);
586 EdonRFinal(EdonRState
*state
, uint8_t *hashval
)
589 uint64_t *data64
, num_bits
;
592 int LastByte
, PadOnePosition
;
594 num_bits
= state
->bits_processed
+ state
->unprocessed_bits
;
595 ASSERT(EDONR_VALID_HASHBITLEN(state
->hashbitlen
));
596 switch (state
->hashbitlen
) {
599 LastByte
= (int)state
->unprocessed_bits
>> 3;
600 PadOnePosition
= 7 - (state
->unprocessed_bits
& 0x07);
601 hashState256(state
)->LastPart
[LastByte
] =
602 (hashState256(state
)->LastPart
[LastByte
]
603 & (0xff << (PadOnePosition
+ 1))) ^
604 (0x01 << PadOnePosition
);
605 /* LINTED E_BAD_PTR_CAST_ALIGN */
606 data64
= (uint64_t *)hashState256(state
)->LastPart
;
608 if (state
->unprocessed_bits
< 448) {
609 (void) memset((hashState256(state
)->LastPart
) +
611 EdonR256_BLOCK_SIZE
- LastByte
- 9);
612 databitlen
= EdonR256_BLOCK_SIZE
* 8;
613 #if defined(MACHINE_IS_BIG_ENDIAN)
614 st_swap64(num_bits
, data64
+ 7);
616 data64
[7] = num_bits
;
619 (void) memset((hashState256(state
)->LastPart
) +
621 EdonR256_BLOCK_SIZE
* 2 - LastByte
- 9);
622 databitlen
= EdonR256_BLOCK_SIZE
* 16;
623 #if defined(MACHINE_IS_BIG_ENDIAN)
624 st_swap64(num_bits
, data64
+ 15);
626 data64
[15] = num_bits
;
630 /* LINTED E_BAD_PTR_CAST_ALIGN */
631 data32
= (uint32_t *)hashState256(state
)->LastPart
;
632 state
->bits_processed
+= Q256(databitlen
, data32
,
633 hashState256(state
)->DoublePipe
);
638 LastByte
= (int)state
->unprocessed_bits
>> 3;
639 PadOnePosition
= 7 - (state
->unprocessed_bits
& 0x07);
640 hashState512(state
)->LastPart
[LastByte
] =
641 (hashState512(state
)->LastPart
[LastByte
]
642 & (0xff << (PadOnePosition
+ 1))) ^
643 (0x01 << PadOnePosition
);
644 /* LINTED E_BAD_PTR_CAST_ALIGN */
645 data64
= (uint64_t *)hashState512(state
)->LastPart
;
647 if (state
->unprocessed_bits
< 960) {
648 (void) memset((hashState512(state
)->LastPart
) +
650 EdonR512_BLOCK_SIZE
- LastByte
- 9);
651 databitlen
= EdonR512_BLOCK_SIZE
* 8;
652 #if defined(MACHINE_IS_BIG_ENDIAN)
653 st_swap64(num_bits
, data64
+ 15);
655 data64
[15] = num_bits
;
658 (void) memset((hashState512(state
)->LastPart
) +
660 EdonR512_BLOCK_SIZE
* 2 - LastByte
- 9);
661 databitlen
= EdonR512_BLOCK_SIZE
* 16;
662 #if defined(MACHINE_IS_BIG_ENDIAN)
663 st_swap64(num_bits
, data64
+ 31);
665 data64
[31] = num_bits
;
669 state
->bits_processed
+= Q512(databitlen
, data64
,
670 hashState512(state
)->DoublePipe
);
674 switch (state
->hashbitlen
) {
676 #if defined(MACHINE_IS_BIG_ENDIAN)
677 uint32_t *d32
= (uint32_t *)hashval
;
678 uint32_t *s32
= hashState224(state
)->DoublePipe
+ 9;
681 for (j
= 0; j
< EdonR224_DIGEST_SIZE
>> 2; j
++)
682 st_swap32(s32
[j
], d32
+ j
);
684 bcopy(hashState256(state
)->DoublePipe
+ 9, hashval
,
685 EdonR224_DIGEST_SIZE
);
690 #if defined(MACHINE_IS_BIG_ENDIAN)
691 uint32_t *d32
= (uint32_t *)hashval
;
692 uint32_t *s32
= hashState224(state
)->DoublePipe
+ 8;
695 for (j
= 0; j
< EdonR256_DIGEST_SIZE
>> 2; j
++)
696 st_swap32(s32
[j
], d32
+ j
);
698 bcopy(hashState256(state
)->DoublePipe
+ 8, hashval
,
699 EdonR256_DIGEST_SIZE
);
704 #if defined(MACHINE_IS_BIG_ENDIAN)
705 uint64_t *d64
= (uint64_t *)hashval
;
706 uint64_t *s64
= hashState384(state
)->DoublePipe
+ 10;
709 for (j
= 0; j
< EdonR384_DIGEST_SIZE
>> 3; j
++)
710 st_swap64(s64
[j
], d64
+ j
);
712 bcopy(hashState384(state
)->DoublePipe
+ 10, hashval
,
713 EdonR384_DIGEST_SIZE
);
718 #if defined(MACHINE_IS_BIG_ENDIAN)
719 uint64_t *d64
= (uint64_t *)hashval
;
720 uint64_t *s64
= hashState512(state
)->DoublePipe
+ 8;
723 for (j
= 0; j
< EdonR512_DIGEST_SIZE
>> 3; j
++)
724 st_swap64(s64
[j
], d64
+ j
);
726 bcopy(hashState512(state
)->DoublePipe
+ 8, hashval
,
727 EdonR512_DIGEST_SIZE
);
736 EdonRHash(size_t hashbitlen
, const uint8_t *data
, size_t databitlen
,
741 EdonRInit(&state
, hashbitlen
);
742 EdonRUpdate(&state
, data
, databitlen
);
743 EdonRFinal(&state
, hashval
);
747 EXPORT_SYMBOL(EdonRInit
);
748 EXPORT_SYMBOL(EdonRUpdate
);
749 EXPORT_SYMBOL(EdonRHash
);
750 EXPORT_SYMBOL(EdonRFinal
);