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

Delta Between Two Patch Sets: Modules/_sha3/kcp/PlSnP-Fallback.inc

Issue 16113: Add SHA-3 (Keccak) support
Left Patch Set: Created 5 years, 8 months ago
Right Patch Set: Created 3 years 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/KeccakSponge.inc ('k') | Modules/_sha3/kcp/SnP-Relaned.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 /* expect PlSnP_baseParallelism, PlSnP_targetParallelism */
17
18 /* expect SnP_stateSizeInBytes, SnP_stateAlignment */
19
20 /* expect prefix */
21
22 /* expect SnP_* */
23
24
25 #define JOIN0(a, b) a ## b
26 #define JOIN(a, b) JOIN0(a, b)
27
28 #define PlSnP_StaticInitialize JOIN(prefix, _StaticInitialize)
29 #define PlSnP_InitializeAll JOIN(prefix, _InitializeAll)
30 #define PlSnP_AddByte JOIN(prefix, _AddByte)
31 #define PlSnP_AddBytes JOIN(prefix, _AddBytes)
32 #define PlSnP_AddLanesAll JOIN(prefix, _AddLanesAll)
33 #define PlSnP_OverwriteBytes JOIN(prefix, _OverwriteBytes)
34 #define PlSnP_OverwriteLanesAll JOIN(prefix, _OverwriteLanesAll)
35 #define PlSnP_OverwriteWithZeroes JOIN(prefix, _OverwriteWithZeroes)
36 #define PlSnP_ExtractBytes JOIN(prefix, _ExtractBytes)
37 #define PlSnP_ExtractLanesAll JOIN(prefix, _ExtractLanesAll)
38 #define PlSnP_ExtractAndAddBytes JOIN(prefix, _ExtractAndAddBytes)
39 #define PlSnP_ExtractAndAddLanesAll JOIN(prefix, _ExtractAndAddLanesAll)
40
41 #if (PlSnP_baseParallelism == 1)
42 #define SnP_stateSizeInBytes JOIN(SnP, _stateSizeInBytes)
43 #define SnP_stateAlignment JOIN(SnP, _stateAlignment)
44 #else
45 #define SnP_stateSizeInBytes JOIN(SnP, _statesSizeInBytes)
46 #define SnP_stateAlignment JOIN(SnP, _statesAlignment)
47 #endif
48 #define PlSnP_factor ((PlSnP_targetParallelism)/(PlSnP_baseParallelism))
49 #define SnP_stateOffset (((SnP_stateSizeInBytes+(SnP_stateAlignment-1))/SnP_stat eAlignment)*SnP_stateAlignment)
50 #define stateWithIndex(i) ((unsigned char *)states+((i)*SnP_stateOffset))
51
52 #define SnP_StaticInitialize JOIN(SnP, _StaticInitialize)
53 #define SnP_Initialize JOIN(SnP, _Initialize)
54 #define SnP_InitializeAll JOIN(SnP, _InitializeAll)
55 #define SnP_AddByte JOIN(SnP, _AddByte)
56 #define SnP_AddBytes JOIN(SnP, _AddBytes)
57 #define SnP_AddLanesAll JOIN(SnP, _AddLanesAll)
58 #define SnP_OverwriteBytes JOIN(SnP, _OverwriteBytes)
59 #define SnP_OverwriteLanesAll JOIN(SnP, _OverwriteLanesAll)
60 #define SnP_OverwriteWithZeroes JOIN(SnP, _OverwriteWithZeroes)
61 #define SnP_ExtractBytes JOIN(SnP, _ExtractBytes)
62 #define SnP_ExtractLanesAll JOIN(SnP, _ExtractLanesAll)
63 #define SnP_ExtractAndAddBytes JOIN(SnP, _ExtractAndAddBytes)
64 #define SnP_ExtractAndAddLanesAll JOIN(SnP, _ExtractAndAddLanesAll)
65
66 void PlSnP_StaticInitialize( void )
67 {
68 SnP_StaticInitialize();
69 }
70
71 void PlSnP_InitializeAll(void *states)
72 {
73 unsigned int i;
74
75 for(i=0; i<PlSnP_factor; i++)
76 #if (PlSnP_baseParallelism == 1)
77 SnP_Initialize(stateWithIndex(i));
78 #else
79 SnP_InitializeAll(stateWithIndex(i));
80 #endif
81 }
82
83 void PlSnP_AddByte(void *states, unsigned int instanceIndex, unsigned char byte, unsigned int offset)
84 {
85 #if (PlSnP_baseParallelism == 1)
86 SnP_AddByte(stateWithIndex(instanceIndex), byte, offset);
87 #else
88 SnP_AddByte(stateWithIndex(instanceIndex/PlSnP_baseParallelism), instanc eIndex%PlSnP_baseParallelism, byte, offset);
89 #endif
90 }
91
92 void PlSnP_AddBytes(void *states, unsigned int instanceIndex, const unsigned cha r *data, unsigned int offset, unsigned int length)
93 {
94 #if (PlSnP_baseParallelism == 1)
95 SnP_AddBytes(stateWithIndex(instanceIndex), data, offset, length);
96 #else
97 SnP_AddBytes(stateWithIndex(instanceIndex/PlSnP_baseParallelism), instan ceIndex%PlSnP_baseParallelism, data, offset, length);
98 #endif
99 }
100
101 void PlSnP_AddLanesAll(void *states, const unsigned char *data, unsigned int lan eCount, unsigned int laneOffset)
102 {
103 unsigned int i;
104
105 for(i=0; i<PlSnP_factor; i++) {
106 #if (PlSnP_baseParallelism == 1)
107 SnP_AddBytes(stateWithIndex(i), data, 0, laneCount*SnP_laneLengthInB ytes);
108 #else
109 SnP_AddLanesAll(stateWithIndex(i), data, laneCount, laneOffset);
110 #endif
111 data += PlSnP_baseParallelism*laneOffset*SnP_laneLengthInBytes;
112 }
113 }
114
115 void PlSnP_OverwriteBytes(void *states, unsigned int instanceIndex, const unsign ed char *data, unsigned int offset, unsigned int length)
116 {
117 #if (PlSnP_baseParallelism == 1)
118 SnP_OverwriteBytes(stateWithIndex(instanceIndex), data, offset, length);
119 #else
120 SnP_OverwriteBytes(stateWithIndex(instanceIndex/PlSnP_baseParallelism), instanceIndex%PlSnP_baseParallelism, data, offset, length);
121 #endif
122 }
123
124 void PlSnP_OverwriteLanesAll(void *states, const unsigned char *data, unsigned i nt laneCount, unsigned int laneOffset)
125 {
126 unsigned int i;
127
128 for(i=0; i<PlSnP_factor; i++) {
129 #if (PlSnP_baseParallelism == 1)
130 SnP_OverwriteBytes(stateWithIndex(i), data, 0, laneCount*SnP_laneLen gthInBytes);
131 #else
132 SnP_OverwriteLanesAll(stateWithIndex(i), data, laneCount, laneOffset );
133 #endif
134 data += PlSnP_baseParallelism*laneOffset*SnP_laneLengthInBytes;
135 }
136 }
137
138 void PlSnP_OverwriteWithZeroes(void *states, unsigned int instanceIndex, unsigne d int byteCount)
139 {
140 #if (PlSnP_baseParallelism == 1)
141 SnP_OverwriteWithZeroes(stateWithIndex(instanceIndex), byteCount);
142 #else
143 SnP_OverwriteWithZeroes(stateWithIndex(instanceIndex/PlSnP_baseParalleli sm), instanceIndex%PlSnP_baseParallelism, byteCount);
144 #endif
145 }
146
147 void PlSnP_PermuteAll(void *states)
148 {
149 unsigned int i;
150
151 for(i=0; i<PlSnP_factor; i++) {
152 #if (PlSnP_baseParallelism == 1)
153 SnP_Permute(stateWithIndex(i));
154 #else
155 SnP_PermuteAll(stateWithIndex(i));
156 #endif
157 }
158 }
159
160 #if (defined(SnP_Permute_12rounds) || defined(SnP_PermuteAll_12rounds))
161 void PlSnP_PermuteAll_12rounds(void *states)
162 {
163 unsigned int i;
164
165 for(i=0; i<PlSnP_factor; i++) {
166 #if (PlSnP_baseParallelism == 1)
167 SnP_Permute_12rounds(stateWithIndex(i));
168 #else
169 SnP_PermuteAll_12rounds(stateWithIndex(i));
170 #endif
171 }
172 }
173 #endif
174
175 void PlSnP_ExtractBytes(void *states, unsigned int instanceIndex, unsigned char *data, unsigned int offset, unsigned int length)
176 {
177 #if (PlSnP_baseParallelism == 1)
178 SnP_ExtractBytes(stateWithIndex(instanceIndex), data, offset, length);
179 #else
180 SnP_ExtractBytes(stateWithIndex(instanceIndex/PlSnP_baseParallelism), in stanceIndex%PlSnP_baseParallelism, data, offset, length);
181 #endif
182 }
183
184 void PlSnP_ExtractLanesAll(const void *states, unsigned char *data, unsigned int laneCount, unsigned int laneOffset)
185 {
186 unsigned int i;
187
188 for(i=0; i<PlSnP_factor; i++) {
189 #if (PlSnP_baseParallelism == 1)
190 SnP_ExtractBytes(stateWithIndex(i), data, 0, laneCount*SnP_laneLengt hInBytes);
191 #else
192 SnP_ExtractLanesAll(stateWithIndex(i), data, laneCount, laneOffset);
193 #endif
194 data += laneOffset*SnP_laneLengthInBytes*PlSnP_baseParallelism;
195 }
196 }
197
198 void PlSnP_ExtractAndAddBytes(void *states, unsigned int instanceIndex, const un signed char *input, unsigned char *output, unsigned int offset, unsigned int len gth)
199 {
200 #if (PlSnP_baseParallelism == 1)
201 SnP_ExtractAndAddBytes(stateWithIndex(instanceIndex), input, output, off set, length);
202 #else
203 SnP_ExtractAndAddBytes(stateWithIndex(instanceIndex/PlSnP_baseParallelis m), instanceIndex%PlSnP_baseParallelism, input, output, offset, length);
204 #endif
205 }
206
207 void PlSnP_ExtractAndAddLanesAll(const void *states, const unsigned char *input, unsigned char *output, unsigned int laneCount, unsigned int laneOffset)
208 {
209 unsigned int i;
210
211 for(i=0; i<PlSnP_factor; i++) {
212 #if (PlSnP_baseParallelism == 1)
213 SnP_ExtractAndAddBytes(stateWithIndex(i), input, output, 0, laneCoun t*SnP_laneLengthInBytes);
214 #else
215 SnP_ExtractAndAddLanesAll(stateWithIndex(i), input, output, laneCoun t, laneOffset);
216 #endif
217 input += laneOffset*SnP_laneLengthInBytes*PlSnP_baseParallelism;
218 output += laneOffset*SnP_laneLengthInBytes*PlSnP_baseParallelism;
219 }
220 }
221
222 #undef PlSnP_factor
223 #undef SnP_stateOffset
224 #undef stateWithIndex
225 #undef JOIN0
226 #undef JOIN
227 #undef PlSnP_StaticInitialize
228 #undef PlSnP_InitializeAll
229 #undef PlSnP_AddByte
230 #undef PlSnP_AddBytes
231 #undef PlSnP_AddLanesAll
232 #undef PlSnP_OverwriteBytes
233 #undef PlSnP_OverwriteLanesAll
234 #undef PlSnP_OverwriteWithZeroes
235 #undef PlSnP_PermuteAll
236 #undef PlSnP_ExtractBytes
237 #undef PlSnP_ExtractLanesAll
238 #undef PlSnP_ExtractAndAddBytes
239 #undef PlSnP_ExtractAndAddLanesAll
240 #undef SnP_stateAlignment
241 #undef SnP_stateSizeInBytes
242 #undef PlSnP_factor
243 #undef SnP_stateOffset
244 #undef stateWithIndex
245 #undef SnP_StaticInitialize
246 #undef SnP_Initialize
247 #undef SnP_InitializeAll
248 #undef SnP_AddByte
249 #undef SnP_AddBytes
250 #undef SnP_AddLanesAll
251 #undef SnP_OverwriteBytes
252 #undef SnP_OverwriteWithZeroes
253 #undef SnP_OverwriteLanesAll
254 #undef SnP_ExtractBytes
255 #undef SnP_ExtractLanesAll
256 #undef SnP_ExtractAndAddBytes
257 #undef SnP_ExtractAndAddLanesAll
LEFTRIGHT

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