Rietveld Code Review Tool
Help | Bug tracker | Discussion group | Source code | Sign in
(38775)

Delta Between Two Patch Sets: Modules/_sha3/kcp/KeccakP-1600-opt64.c

Issue 16113: Add SHA-3 (Keccak) support
Left Patch Set: Created 6 years, 11 months ago
Right Patch Set: Created 3 years, 1 month ago
Left:
Right:
Use n/p to move between diff chunks; N/P to move between comments. Please Sign in to add in-line comments.
Jump to:
Right: Side by side diff | Download
« no previous file with change/comment | « Modules/_sha3/kcp/KeccakP-1600-inplace32BI.c ('k') | Modules/_sha3/kcp/KeccakP-1600-opt64-config.h » ('j') | no next file with change/comment »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
LEFTRIGHT
(no file at all)
1 /*
2 Implementation by the Keccak, Keyak and Ketje Teams, namely, Guido Bertoni,
3 Joan Daemen, Michaƫl Peeters, Gilles Van Assche and Ronny Van Keer, hereby
4 denoted as "the implementer".
5
6 For more information, feedback or questions, please refer to our websites:
7 http://keccak.noekeon.org/
8 http://keyak.noekeon.org/
9 http://ketje.noekeon.org/
10
11 To the extent possible under law, the implementer has waived all copyright
12 and related or neighboring rights to the source code in this file.
13 http://creativecommons.org/publicdomain/zero/1.0/
14 */
15
16 #include <string.h>
17 #include <stdlib.h>
18 /* #include "brg_endian.h" */
19 #include "KeccakP-1600-opt64-config.h"
20
21 #if NOT_PYTHON
22 typedef unsigned char UINT8;
23 /* typedef unsigned long long int UINT64; */
24 #endif
25
26 #if defined(KeccakP1600_useLaneComplementing)
27 #define UseBebigokimisa
28 #endif
29
30 #if defined(_MSC_VER)
31 #define ROL64(a, offset) _rotl64(a, offset)
32 #elif defined(KeccakP1600_useSHLD)
33 #define ROL64(x,N) ({ \
34 register UINT64 __out; \
35 register UINT64 __in = x; \
36 __asm__ ("shld %2,%0,%0" : "=r"(__out) : "0"(__in), "i"(N)); \
37 __out; \
38 })
39 #else
40 #define ROL64(a, offset) ((((UINT64)a) << offset) ^ (((UINT64)a) >> (64-offset)) )
41 #endif
42
43 #include "KeccakP-1600-64.macros"
44 #ifdef KeccakP1600_fullUnrolling
45 #define FullUnrolling
46 #else
47 #define Unrolling KeccakP1600_unrolling
48 #endif
49 #include "KeccakP-1600-unrolling.macros"
50 #include "SnP-Relaned.h"
51
52 static const UINT64 KeccakF1600RoundConstants[24] = {
53 0x0000000000000001ULL,
54 0x0000000000008082ULL,
55 0x800000000000808aULL,
56 0x8000000080008000ULL,
57 0x000000000000808bULL,
58 0x0000000080000001ULL,
59 0x8000000080008081ULL,
60 0x8000000000008009ULL,
61 0x000000000000008aULL,
62 0x0000000000000088ULL,
63 0x0000000080008009ULL,
64 0x000000008000000aULL,
65 0x000000008000808bULL,
66 0x800000000000008bULL,
67 0x8000000000008089ULL,
68 0x8000000000008003ULL,
69 0x8000000000008002ULL,
70 0x8000000000000080ULL,
71 0x000000000000800aULL,
72 0x800000008000000aULL,
73 0x8000000080008081ULL,
74 0x8000000000008080ULL,
75 0x0000000080000001ULL,
76 0x8000000080008008ULL };
77
78 /* ---------------------------------------------------------------- */
79
80 void KeccakP1600_Initialize(void *state)
81 {
82 memset(state, 0, 200);
83 #ifdef KeccakP1600_useLaneComplementing
84 ((UINT64*)state)[ 1] = ~(UINT64)0;
85 ((UINT64*)state)[ 2] = ~(UINT64)0;
86 ((UINT64*)state)[ 8] = ~(UINT64)0;
87 ((UINT64*)state)[12] = ~(UINT64)0;
88 ((UINT64*)state)[17] = ~(UINT64)0;
89 ((UINT64*)state)[20] = ~(UINT64)0;
90 #endif
91 }
92
93 /* ---------------------------------------------------------------- */
94
95 void KeccakP1600_AddBytesInLane(void *state, unsigned int lanePosition, const un signed char *data, unsigned int offset, unsigned int length)
96 {
97 #if (PLATFORM_BYTE_ORDER == IS_LITTLE_ENDIAN)
98 UINT64 lane;
99 if (length == 0)
100 return;
101 if (length == 1)
102 lane = data[0];
103 else {
104 lane = 0;
105 memcpy(&lane, data, length);
106 }
107 lane <<= offset*8;
108 #else
109 UINT64 lane = 0;
110 unsigned int i;
111 for(i=0; i<length; i++)
112 lane |= ((UINT64)data[i]) << ((i+offset)*8);
113 #endif
114 ((UINT64*)state)[lanePosition] ^= lane;
115 }
116
117 /* ---------------------------------------------------------------- */
118
119 void KeccakP1600_AddLanes(void *state, const unsigned char *data, unsigned int l aneCount)
120 {
121 #if (PLATFORM_BYTE_ORDER == IS_LITTLE_ENDIAN)
122 unsigned int i = 0;
123 #ifdef NO_MISALIGNED_ACCESSES
124 /* If either pointer is misaligned, fall back to byte-wise xor. */
125
126 if (((((uintptr_t)state) & 7) != 0) || ((((uintptr_t)data) & 7) != 0)) {
127 for (i = 0; i < laneCount * 8; i++) {
128 ((unsigned char*)state)[i] ^= data[i];
129 }
130 }
131 else
132 #endif
133 {
134 /* Otherwise... */
135
136 for( ; (i+8)<=laneCount; i+=8) {
137 ((UINT64*)state)[i+0] ^= ((UINT64*)data)[i+0];
138 ((UINT64*)state)[i+1] ^= ((UINT64*)data)[i+1];
139 ((UINT64*)state)[i+2] ^= ((UINT64*)data)[i+2];
140 ((UINT64*)state)[i+3] ^= ((UINT64*)data)[i+3];
141 ((UINT64*)state)[i+4] ^= ((UINT64*)data)[i+4];
142 ((UINT64*)state)[i+5] ^= ((UINT64*)data)[i+5];
143 ((UINT64*)state)[i+6] ^= ((UINT64*)data)[i+6];
144 ((UINT64*)state)[i+7] ^= ((UINT64*)data)[i+7];
145 }
146 for( ; (i+4)<=laneCount; i+=4) {
147 ((UINT64*)state)[i+0] ^= ((UINT64*)data)[i+0];
148 ((UINT64*)state)[i+1] ^= ((UINT64*)data)[i+1];
149 ((UINT64*)state)[i+2] ^= ((UINT64*)data)[i+2];
150 ((UINT64*)state)[i+3] ^= ((UINT64*)data)[i+3];
151 }
152 for( ; (i+2)<=laneCount; i+=2) {
153 ((UINT64*)state)[i+0] ^= ((UINT64*)data)[i+0];
154 ((UINT64*)state)[i+1] ^= ((UINT64*)data)[i+1];
155 }
156 if (i<laneCount) {
157 ((UINT64*)state)[i+0] ^= ((UINT64*)data)[i+0];
158 }
159 }
160 #else
161 unsigned int i;
162 UINT8 *curData = data;
163 for(i=0; i<laneCount; i++, curData+=8) {
164 UINT64 lane = (UINT64)curData[0]
165 | ((UINT64)curData[1] << 8)
166 | ((UINT64)curData[2] << 16)
167 | ((UINT64)curData[3] << 24)
168 | ((UINT64)curData[4] <<32)
169 | ((UINT64)curData[5] << 40)
170 | ((UINT64)curData[6] << 48)
171 | ((UINT64)curData[7] << 56);
172 ((UINT64*)state)[i] ^= lane;
173 }
174 #endif
175 }
176
177 /* ---------------------------------------------------------------- */
178
179 #if (PLATFORM_BYTE_ORDER != IS_LITTLE_ENDIAN)
180 void KeccakP1600_AddByte(void *state, unsigned char byte, unsigned int offset)
181 {
182 UINT64 lane = byte;
183 lane <<= (offset%8)*8;
184 ((UINT64*)state)[offset/8] ^= lane;
185 }
186 #endif
187
188 /* ---------------------------------------------------------------- */
189
190 void KeccakP1600_AddBytes(void *state, const unsigned char *data, unsigned int o ffset, unsigned int length)
191 {
192 SnP_AddBytes(state, data, offset, length, KeccakP1600_AddLanes, KeccakP1600_ AddBytesInLane, 8);
193 }
194
195 /* ---------------------------------------------------------------- */
196
197 void KeccakP1600_OverwriteBytesInLane(void *state, unsigned int lanePosition, co nst unsigned char *data, unsigned int offset, unsigned int length)
198 {
199 #if (PLATFORM_BYTE_ORDER == IS_LITTLE_ENDIAN)
200 #ifdef KeccakP1600_useLaneComplementing
201 if ((lanePosition == 1) || (lanePosition == 2) || (lanePosition == 8) || (la nePosition == 12) || (lanePosition == 17) || (lanePosition == 20)) {
202 unsigned int i;
203 for(i=0; i<length; i++)
204 ((unsigned char*)state)[lanePosition*8+offset+i] = ~data[i];
205 }
206 else
207 #endif
208 {
209 memcpy((unsigned char*)state+lanePosition*8+offset, data, length);
210 }
211 #else
212 #error "Not yet implemented"
213 #endif
214 }
215
216 /* ---------------------------------------------------------------- */
217
218 void KeccakP1600_OverwriteLanes(void *state, const unsigned char *data, unsigned int laneCount)
219 {
220 #if (PLATFORM_BYTE_ORDER == IS_LITTLE_ENDIAN)
221 #ifdef KeccakP1600_useLaneComplementing
222 unsigned int lanePosition;
223
224 for(lanePosition=0; lanePosition<laneCount; lanePosition++)
225 if ((lanePosition == 1) || (lanePosition == 2) || (lanePosition == 8) || (lanePosition == 12) || (lanePosition == 17) || (lanePosition == 20))
226 ((UINT64*)state)[lanePosition] = ~((const UINT64*)data)[lanePosition ];
227 else
228 ((UINT64*)state)[lanePosition] = ((const UINT64*)data)[lanePosition] ;
229 #else
230 memcpy(state, data, laneCount*8);
231 #endif
232 #else
233 #error "Not yet implemented"
234 #endif
235 }
236
237 /* ---------------------------------------------------------------- */
238
239 void KeccakP1600_OverwriteBytes(void *state, const unsigned char *data, unsigned int offset, unsigned int length)
240 {
241 SnP_OverwriteBytes(state, data, offset, length, KeccakP1600_OverwriteLanes, KeccakP1600_OverwriteBytesInLane, 8);
242 }
243
244 /* ---------------------------------------------------------------- */
245
246 void KeccakP1600_OverwriteWithZeroes(void *state, unsigned int byteCount)
247 {
248 #if (PLATFORM_BYTE_ORDER == IS_LITTLE_ENDIAN)
249 #ifdef KeccakP1600_useLaneComplementing
250 unsigned int lanePosition;
251
252 for(lanePosition=0; lanePosition<byteCount/8; lanePosition++)
253 if ((lanePosition == 1) || (lanePosition == 2) || (lanePosition == 8) || (lanePosition == 12) || (lanePosition == 17) || (lanePosition == 20))
254 ((UINT64*)state)[lanePosition] = ~0;
255 else
256 ((UINT64*)state)[lanePosition] = 0;
257 if (byteCount%8 != 0) {
258 lanePosition = byteCount/8;
259 if ((lanePosition == 1) || (lanePosition == 2) || (lanePosition == 8) || (lanePosition == 12) || (lanePosition == 17) || (lanePosition == 20))
260 memset((unsigned char*)state+lanePosition*8, 0xFF, byteCount%8);
261 else
262 memset((unsigned char*)state+lanePosition*8, 0, byteCount%8);
263 }
264 #else
265 memset(state, 0, byteCount);
266 #endif
267 #else
268 #error "Not yet implemented"
269 #endif
270 }
271
272 /* ---------------------------------------------------------------- */
273
274 void KeccakP1600_Permute_24rounds(void *state)
275 {
276 declareABCDE
277 #ifndef KeccakP1600_fullUnrolling
278 unsigned int i;
279 #endif
280 UINT64 *stateAsLanes = (UINT64*)state;
281
282 copyFromState(A, stateAsLanes)
283 rounds24
284 copyToState(stateAsLanes, A)
285 }
286
287 /* ---------------------------------------------------------------- */
288
289 void KeccakP1600_Permute_12rounds(void *state)
290 {
291 declareABCDE
292 #ifndef KeccakP1600_fullUnrolling
293 unsigned int i;
294 #endif
295 UINT64 *stateAsLanes = (UINT64*)state;
296
297 copyFromState(A, stateAsLanes)
298 rounds12
299 copyToState(stateAsLanes, A)
300 }
301
302 /* ---------------------------------------------------------------- */
303
304 void KeccakP1600_ExtractBytesInLane(const void *state, unsigned int lanePosition , unsigned char *data, unsigned int offset, unsigned int length)
305 {
306 UINT64 lane = ((UINT64*)state)[lanePosition];
307 #ifdef KeccakP1600_useLaneComplementing
308 if ((lanePosition == 1) || (lanePosition == 2) || (lanePosition == 8) || (la nePosition == 12) || (lanePosition == 17) || (lanePosition == 20))
309 lane = ~lane;
310 #endif
311 #if (PLATFORM_BYTE_ORDER == IS_LITTLE_ENDIAN)
312 {
313 UINT64 lane1[1];
314 lane1[0] = lane;
315 memcpy(data, (UINT8*)lane1+offset, length);
316 }
317 #else
318 unsigned int i;
319 lane >>= offset*8;
320 for(i=0; i<length; i++) {
321 data[i] = lane & 0xFF;
322 lane >>= 8;
323 }
324 #endif
325 }
326
327 /* ---------------------------------------------------------------- */
328
329 #if (PLATFORM_BYTE_ORDER != IS_LITTLE_ENDIAN)
330 void fromWordToBytes(UINT8 *bytes, const UINT64 word)
331 {
332 unsigned int i;
333
334 for(i=0; i<(64/8); i++)
335 bytes[i] = (word >> (8*i)) & 0xFF;
336 }
337 #endif
338
339 void KeccakP1600_ExtractLanes(const void *state, unsigned char *data, unsigned i nt laneCount)
340 {
341 #if (PLATFORM_BYTE_ORDER == IS_LITTLE_ENDIAN)
342 memcpy(data, state, laneCount*8);
343 #else
344 unsigned int i;
345
346 for(i=0; i<laneCount; i++)
347 fromWordToBytes(data+(i*8), ((const UINT64*)state)[i]);
348 #endif
349 #ifdef KeccakP1600_useLaneComplementing
350 if (laneCount > 1) {
351 ((UINT64*)data)[ 1] = ~((UINT64*)data)[ 1];
352 if (laneCount > 2) {
353 ((UINT64*)data)[ 2] = ~((UINT64*)data)[ 2];
354 if (laneCount > 8) {
355 ((UINT64*)data)[ 8] = ~((UINT64*)data)[ 8];
356 if (laneCount > 12) {
357 ((UINT64*)data)[12] = ~((UINT64*)data)[12];
358 if (laneCount > 17) {
359 ((UINT64*)data)[17] = ~((UINT64*)data)[17];
360 if (laneCount > 20) {
361 ((UINT64*)data)[20] = ~((UINT64*)data)[20];
362 }
363 }
364 }
365 }
366 }
367 }
368 #endif
369 }
370
371 /* ---------------------------------------------------------------- */
372
373 void KeccakP1600_ExtractBytes(const void *state, unsigned char *data, unsigned i nt offset, unsigned int length)
374 {
375 SnP_ExtractBytes(state, data, offset, length, KeccakP1600_ExtractLanes, Kecc akP1600_ExtractBytesInLane, 8);
376 }
377
378 /* ---------------------------------------------------------------- */
379
380 void KeccakP1600_ExtractAndAddBytesInLane(const void *state, unsigned int lanePo sition, const unsigned char *input, unsigned char *output, unsigned int offset, unsigned int length)
381 {
382 UINT64 lane = ((UINT64*)state)[lanePosition];
383 #ifdef KeccakP1600_useLaneComplementing
384 if ((lanePosition == 1) || (lanePosition == 2) || (lanePosition == 8) || (la nePosition == 12) || (lanePosition == 17) || (lanePosition == 20))
385 lane = ~lane;
386 #endif
387 #if (PLATFORM_BYTE_ORDER == IS_LITTLE_ENDIAN)
388 {
389 unsigned int i;
390 UINT64 lane1[1];
391 lane1[0] = lane;
392 for(i=0; i<length; i++)
393 output[i] = input[i] ^ ((UINT8*)lane1)[offset+i];
394 }
395 #else
396 unsigned int i;
397 lane >>= offset*8;
398 for(i=0; i<length; i++) {
399 output[i] = input[i] ^ (lane & 0xFF);
400 lane >>= 8;
401 }
402 #endif
403 }
404
405 /* ---------------------------------------------------------------- */
406
407 void KeccakP1600_ExtractAndAddLanes(const void *state, const unsigned char *inpu t, unsigned char *output, unsigned int laneCount)
408 {
409 unsigned int i;
410 #if (PLATFORM_BYTE_ORDER != IS_LITTLE_ENDIAN)
411 unsigned char temp[8];
412 unsigned int j;
413 #endif
414
415 for(i=0; i<laneCount; i++) {
416 #if (PLATFORM_BYTE_ORDER == IS_LITTLE_ENDIAN)
417 ((UINT64*)output)[i] = ((UINT64*)input)[i] ^ ((const UINT64*)state)[i];
418 #else
419 fromWordToBytes(temp, ((const UINT64*)state)[i]);
420 for(j=0; j<8; j++)
421 output[i*8+j] = input[i*8+j] ^ temp[j];
422 #endif
423 }
424 #ifdef KeccakP1600_useLaneComplementing
425 if (laneCount > 1) {
426 ((UINT64*)output)[ 1] = ~((UINT64*)output)[ 1];
427 if (laneCount > 2) {
428 ((UINT64*)output)[ 2] = ~((UINT64*)output)[ 2];
429 if (laneCount > 8) {
430 ((UINT64*)output)[ 8] = ~((UINT64*)output)[ 8];
431 if (laneCount > 12) {
432 ((UINT64*)output)[12] = ~((UINT64*)output)[12];
433 if (laneCount > 17) {
434 ((UINT64*)output)[17] = ~((UINT64*)output)[17];
435 if (laneCount > 20) {
436 ((UINT64*)output)[20] = ~((UINT64*)output)[20];
437 }
438 }
439 }
440 }
441 }
442 }
443 #endif
444 }
445
446 /* ---------------------------------------------------------------- */
447
448 void KeccakP1600_ExtractAndAddBytes(const void *state, const unsigned char *inpu t, unsigned char *output, unsigned int offset, unsigned int length)
449 {
450 SnP_ExtractAndAddBytes(state, input, output, offset, length, KeccakP1600_Ext ractAndAddLanes, KeccakP1600_ExtractAndAddBytesInLane, 8);
451 }
452
453 /* ---------------------------------------------------------------- */
454
455 size_t KeccakF1600_FastLoop_Absorb(void *state, unsigned int laneCount, const un signed char *data, size_t dataByteLen)
456 {
457 size_t originalDataByteLen = dataByteLen;
458 declareABCDE
459 #ifndef KeccakP1600_fullUnrolling
460 unsigned int i;
461 #endif
462 UINT64 *stateAsLanes = (UINT64*)state;
463 UINT64 *inDataAsLanes = (UINT64*)data;
464
465 copyFromState(A, stateAsLanes)
466 while(dataByteLen >= laneCount*8) {
467 addInput(A, inDataAsLanes, laneCount)
468 rounds24
469 inDataAsLanes += laneCount;
470 dataByteLen -= laneCount*8;
471 }
472 copyToState(stateAsLanes, A)
473 return originalDataByteLen - dataByteLen;
474 }
LEFTRIGHT

RSS Feeds Recent Issues | This issue
This is Rietveld 894c83f36cb7+