Debian Codegraph @

crypto_kem/6960119pcf/avx/benes.c

raw
1 /*
2 This file is for Benes network related functions
3
4 For the implementation strategy, see
5 https://eprint.iacr.org/2017/793.pdf
6 */
7 // 20221231 djb: remove unused counter increment; tnx thom wiggers
8 // 20221230 djb: add linker lines
9
10 // linker define load_bits benes
11 // linker use transpose_64x128_sp_asm
12
13 #include "benes.h"
14
15 #include "util.h"
16 #include "transpose.h"
17 #include "params.h"
18
19 static void layer_x(vec128 * data, vec128 * bits)
20 {
21 int i;
22 vec128 v0, v1;
23 vec128 d;
24
25 for (i = 0; i < 64; i += 2)
26 {
27 v0 = vec128_unpack_low(data[i+0], data[i+1]);
28 v1 = vec128_unpack_high(data[i+0], data[i+1]);
29
30 d = vec128_xor(v0, v1);
31 d = vec128_and(d, *bits++);
32 v0 = vec128_xor(v0, d);
33 v1 = vec128_xor(v1, d);
34
35 data[i+0] = vec128_unpack_low(v0, v1);
36 data[i+1] = vec128_unpack_high(v0, v1);
37 }
38 }
39
40 static void layer_0(vec128 *bs, vec128 *cond)
41 {
42 int x;
43 vec128 diff;
44
45 for (x = 0; x < (1 << 6); x += 2)
46 {
47 diff = vec128_xor(bs[ x ], bs[ x+1 ]);
48 diff = vec128_and(diff, *cond++);
49 bs[ x ] = vec128_xor(bs[ x ], diff);
50 bs[ x+1 ] = vec128_xor(bs[ x+1 ], diff);
51 }
52 }
53
54 static void layer_1(vec128 *bs, vec128 *cond)
55 {
56 int x;
57 vec128 diff;
58
59 for (x = 0; x < (1 << 6); x += 4)
60 {
61 diff = vec128_xor(bs[ x+0 ], bs[ x+2 ]);
62 diff = vec128_and(diff, cond[0]);
63 bs[ x+0 ] = vec128_xor(bs[ x+0 ], diff);
64 bs[ x+2 ] = vec128_xor(bs[ x+2 ], diff);
65
66 diff = vec128_xor(bs[ x+1 ], bs[ x+3 ]);
67 diff = vec128_and(diff, cond[1]);
68 bs[ x+1 ] = vec128_xor(bs[ x+1 ], diff);
69 bs[ x+3 ] = vec128_xor(bs[ x+3 ], diff);
70
71 cond += 2;
72 }
73 }
74
75 static void layer_2(vec128 *bs, vec128 *cond)
76 {
77 int x;
78 vec128 diff;
79
80 for (x = 0; x < (1 << 6); x += 8)
81 {
82 diff = vec128_xor(bs[ x+0 ], bs[ x+4 ]);
83 diff = vec128_and(diff, cond[0]);
84 bs[ x+0 ] = vec128_xor(bs[ x+0 ], diff);
85 bs[ x+4 ] = vec128_xor(bs[ x+4 ], diff);
86
87 diff = vec128_xor(bs[ x+1 ], bs[ x+5 ]);
88 diff = vec128_and(diff, cond[1]);
89 bs[ x+1 ] = vec128_xor(bs[ x+1 ], diff);
90 bs[ x+5 ] = vec128_xor(bs[ x+5 ], diff);
91
92 diff = vec128_xor(bs[ x+2 ], bs[ x+6 ]);
93 diff = vec128_and(diff, cond[2]);
94 bs[ x+2 ] = vec128_xor(bs[ x+2 ], diff);
95 bs[ x+6 ] = vec128_xor(bs[ x+6 ], diff);
96
97 diff = vec128_xor(bs[ x+3 ], bs[ x+7 ]);
98 diff = vec128_and(diff, cond[3]);
99 bs[ x+3 ] = vec128_xor(bs[ x+3 ], diff);
100 bs[ x+7 ] = vec128_xor(bs[ x+7 ], diff);
101
102 cond += 4;
103 }
104 }
105
106 static void layer_3(vec128 *bs, vec128 *cond)
107 {
108 int x, s;
109 vec128 diff;
110
111 for (x = 0; x < (1 << 6); x += 16)
112 for (s = x; s < x + 8; s += 4)
113 {
114 diff = vec128_xor(bs[ s+0 ], bs[ s+8 ]);
115 diff = vec128_and(diff, cond[0]);
116 bs[ s+0 ] = vec128_xor(bs[ s+0 ], diff);
117 bs[ s+8 ] = vec128_xor(bs[ s+8 ], diff);
118
119 diff = vec128_xor(bs[ s+1 ], bs[ s+9 ]);
120 diff = vec128_and(diff, cond[1]);
121 bs[ s+1 ] = vec128_xor(bs[ s+1 ], diff);
122 bs[ s+9 ] = vec128_xor(bs[ s+9 ], diff);
123
124 diff = vec128_xor(bs[ s+2 ], bs[ s+10 ]);
125 diff = vec128_and(diff, cond[2]);
126 bs[ s+2 ] = vec128_xor(bs[ s+2 ], diff);
127 bs[ s+10 ] = vec128_xor(bs[ s+10 ], diff);
128
129 diff = vec128_xor(bs[ s+3 ], bs[ s+11 ]);
130 diff = vec128_and(diff, cond[3]);
131 bs[ s+3 ] = vec128_xor(bs[ s+3 ], diff);
132 bs[ s+11 ] = vec128_xor(bs[ s+11 ], diff);
133
134 cond += 4;
135 }
136 }
137
138 static void layer_4(vec128 *bs, vec128 *cond)
139 {
140 int x, s;
141 vec128 diff;
142
143 for (x = 0; x < (1 << 6); x += 32)
144 for (s = x; s < x + 16; s += 4)
145 {
146 diff = vec128_xor(bs[ s+0 ], bs[ s+16 ]);
147 diff = vec128_and(diff, cond[0]);
148 bs[ s+0 ] = vec128_xor(bs[ s+0 ], diff);
149 bs[ s+16 ] = vec128_xor(bs[ s+16 ], diff);
150
151 diff = vec128_xor(bs[ s+1 ], bs[ s+17 ]);
152 diff = vec128_and(diff, cond[1]);
153 bs[ s+1 ] = vec128_xor(bs[ s+1 ], diff);
154 bs[ s+17 ] = vec128_xor(bs[ s+17 ], diff);
155
156 diff = vec128_xor(bs[ s+2 ], bs[ s+18 ]);
157 diff = vec128_and(diff, cond[2]);
158 bs[ s+2 ] = vec128_xor(bs[ s+2 ], diff);
159 bs[ s+18 ] = vec128_xor(bs[ s+18 ], diff);
160
161 diff = vec128_xor(bs[ s+3 ], bs[ s+19 ]);
162 diff = vec128_and(diff, cond[3]);
163 bs[ s+3 ] = vec128_xor(bs[ s+3 ], diff);
164 bs[ s+19 ] = vec128_xor(bs[ s+19 ], diff);
165
166 cond += 4;
167 }
168 }
169
170 static void layer_5(vec128 *bs, vec128 *cond)
171 {
172 int x, s;
173 vec128 diff;
174
175 for (x = 0; x < (1 << 6); x += 64)
176 for (s = x; s < x + 32; s += 4)
177 {
178 diff = vec128_xor(bs[ s+0 ], bs[ s+32 ]);
179 diff = vec128_and(diff, cond[0]);
180 bs[ s+0 ] = vec128_xor(bs[ s+0 ], diff);
181 bs[ s+32 ] = vec128_xor(bs[ s+32 ], diff);
182
183 diff = vec128_xor(bs[ s+1 ], bs[ s+33 ]);
184 diff = vec128_and(diff, cond[1]);
185 bs[ s+1 ] = vec128_xor(bs[ s+1 ], diff);
186 bs[ s+33 ] = vec128_xor(bs[ s+33 ], diff);
187
188 diff = vec128_xor(bs[ s+2 ], bs[ s+34 ]);
189 diff = vec128_and(diff, cond[2]);
190 bs[ s+2 ] = vec128_xor(bs[ s+2 ], diff);
191 bs[ s+34 ] = vec128_xor(bs[ s+34 ], diff);
192
193 diff = vec128_xor(bs[ s+3 ], bs[ s+35 ]);
194 diff = vec128_and(diff, cond[3]);
195 bs[ s+3 ] = vec128_xor(bs[ s+3 ], diff);
196 bs[ s+35 ] = vec128_xor(bs[ s+35 ], diff);
197
198 cond += 4;
199 }
200 }
201
202 /* input: bits, control bits as array of bytes */
203 /* output: bits_int, control bits as array of 128-bit vectors */
204 void load_bits(vec128 bits_int[][32], const unsigned char * bits)
205 {
206 int i, j;
207 const unsigned char *ptr = bits;
208
209 vec128 buf[64];
210
211 for (i = 0; i <= 5; i += 2)
212 {
213 for (j = 0; j < 64; j++)
214 {
215 buf[j] = vec128_set2x(load8(ptr), load8(ptr + 512));
216 ptr += 8;
217 }
218
219 transpose_64x128_sp( buf );
220
221 for (j = 0; j < 32; j++)
222 {
223 bits_int[i+0][j] = vec128_unpack_low(buf[j], buf[j+32]);
224 bits_int[i+1][j] = vec128_unpack_high(buf[j], buf[j+32]);
225 }
226
227 ptr += 512;
228 }
229
230 for (i = 6; i <= 18; i++)
231 for (j = 0; j < 32; j++)
232 {
233 bits_int[i][j] = load16(ptr); ptr += 16;
234 }
235
236 for (i = 19; i < 25; i += 2)
237 {
238 for (j = 0; j < 64; j++)
239 {
240 buf[j] = vec128_set2x(load8(ptr), load8(ptr + 512));
241 ptr += 8;
242 }
243
244 transpose_64x128_sp( buf );
245
246 for (j = 0; j < 32; j++)
247 {
248 bits_int[i+0][j] = vec128_unpack_low(buf[j], buf[j+32]);
249 bits_int[i+1][j] = vec128_unpack_high(buf[j], buf[j+32]);
250 }
251
252 ptr += 512;
253 }
254 }
255
256 /* input: r, sequence of bits to be permuted */
257 /* b, control bits as array of 128-bit vectors */
258 /* rev, 0 for normal application; !0 for inverse */
259 /* output: r, permuted bits */
260 void benes(vec128 * r, vec128 b[][32], int rev)
261 {
262 int inc;
263
264 vec128 *b_ptr = b[0];
265
266 if (rev == 0) { inc = 32; b_ptr = b[ 0]; }
267 else { inc = -32; b_ptr = b[24]; }
268
269 //
270
271 transpose_64x128_sp( r );
272
273 layer_0(r, b_ptr); b_ptr += inc;
274 layer_1(r, b_ptr); b_ptr += inc;
275 layer_2(r, b_ptr); b_ptr += inc;
276 layer_3(r, b_ptr); b_ptr += inc;
277 layer_4(r, b_ptr); b_ptr += inc;
278 layer_5(r, b_ptr); b_ptr += inc;
279
280 transpose_64x128_sp( r );
281
282 layer_x(r, b_ptr); b_ptr += inc;
283 layer_0(r, b_ptr); b_ptr += inc;
284 layer_1(r, b_ptr); b_ptr += inc;
285 layer_2(r, b_ptr); b_ptr += inc;
286 layer_3(r, b_ptr); b_ptr += inc;
287 layer_4(r, b_ptr); b_ptr += inc;
288 layer_5(r, b_ptr); b_ptr += inc;
289 layer_4(r, b_ptr); b_ptr += inc;
290 layer_3(r, b_ptr); b_ptr += inc;
291 layer_2(r, b_ptr); b_ptr += inc;
292 layer_1(r, b_ptr); b_ptr += inc;
293 layer_0(r, b_ptr); b_ptr += inc;
294 layer_x(r, b_ptr); b_ptr += inc;
295
296 transpose_64x128_sp( r );
297
298 layer_5(r, b_ptr); b_ptr += inc;
299 layer_4(r, b_ptr); b_ptr += inc;
300 layer_3(r, b_ptr); b_ptr += inc;
301 layer_2(r, b_ptr); b_ptr += inc;
302 layer_1(r, b_ptr); b_ptr += inc;
303 layer_0(r, b_ptr);
304
305 transpose_64x128_sp( r );
306 }
307