Debian Codegraph @

crypto_kem/6688128f/avx/decrypt.c

raw
1 /*
2 This file is for Niederreiter decryption
3 */
4 // 20240805 djb: more mask usage
5 // 20240503 djb: remove #ifdef KAT ... #endif
6 // 20221230 djb: add linker lines
7
8 // linker define decrypt
9 // linker use benes bm fft fft_tr
10 // linker use load_bits
11 // linker use vec256_mul_asm vec256_sq vec256_inv
12
13 #include "decrypt.h"
14
15 #include "params.h"
16 #include "fft_tr.h"
17 #include "benes.h"
18 #include "util.h"
19 #include "fft.h"
20 #include "bm.h"
21
22 #include "crypto_int16.h"
23
24 static void scaling(vec256 out[][GFBITS], vec256 inv[][GFBITS], const unsigned char *sk, vec256 *recv)
25 {
26 int i, j;
27
28 vec128 sk_int[ GFBITS ];
29 vec256 eval[32][ GFBITS ];
30 vec256 tmp[ GFBITS ];
31
32 // computing inverses
33
34 irr_load(sk_int, sk);
35
36 fft(eval, sk_int);
37
38 for (i = 0; i < 32; i++)
39 vec256_sq(eval[i], eval[i]);
40
41 vec256_copy(inv[0], eval[0]);
42
43 for (i = 1; i < 32; i++)
44 vec256_mul(inv[i], inv[i-1], eval[i]);
45
46 vec256_inv(tmp, inv[31]);
47
48 for (i = 30; i >= 0; i--)
49 {
50 vec256_mul(inv[i+1], tmp, inv[i]);
51 vec256_mul(tmp, tmp, eval[i+1]);
52 }
53
54 vec256_copy(inv[0], tmp);
55
56 //
57
58 for (i = 0; i < 32; i++)
59 for (j = 0; j < GFBITS; j++)
60 out[i][j] = vec256_and(inv[i][j], recv[i]);
61 }
62
63 static void preprocess(vec128 *recv, const unsigned char *s)
64 {
65 int i;
66 unsigned char r[ 1024 ];
67
68 for (i = 0; i < SYND_BYTES; i++)
69 r[i] = s[i];
70
71 for (i = SYND_BYTES; i < 1024; i++)
72 r[i] = 0;
73
74 for (i = 0; i < 64; i++)
75 recv[i] = load16(r + i*16);
76 }
77
78 static void postprocess(unsigned char * e, vec128 * err)
79 {
80 int i;
81 unsigned char error8[ (1 << GFBITS)/8 ];
82 uint64_t v[2];
83
84 for (i = 0; i < 64; i++)
85 {
86 v[0] = vec128_extract(err[i], 0);
87 v[1] = vec128_extract(err[i], 1);
88
89 store8(error8 + i*16 + 0, v[0]);
90 store8(error8 + i*16 + 8, v[1]);
91 }
92
93 for (i = 0; i < SYS_N/8; i++)
94 e[i] = error8[i];
95 }
96
97 static void scaling_inv(vec256 out[][GFBITS], vec256 inv[][GFBITS], vec256 *recv)
98 {
99 int i, j;
100
101 for (i = 0; i < 32; i++)
102 for (j = 0; j < GFBITS; j++)
103 out[i][j] = vec256_and(inv[i][j], recv[i]);
104 }
105
106 static int weight_check(unsigned char * e, vec128 * error)
107 {
108 int i;
109 uint16_t w0 = 0;
110 uint16_t w1 = 0;
111 uint16_t check;
112
113 for (i = 0; i < 64; i++)
114 {
115 w0 += __builtin_popcountll( vec128_extract(error[i], 0) );
116 w0 += __builtin_popcountll( vec128_extract(error[i], 1) );
117 }
118
119 for (i = 0; i < SYS_N/8; i++)
120 w1 += __builtin_popcountll( e[i] );
121
122 check = (w0 ^ SYS_T) | (w1 ^ SYS_T);
123 return -crypto_int16_zero_mask(check);
124 }
125
126 static uint64_t synd_cmp(vec256 *s0 , vec256 *s1)
127 {
128 int i;
129 vec256 diff;
130
131 diff = vec256_xor(s0[0], s1[0]);
132
133 for (i = 1; i < GFBITS; i++)
134 diff = vec256_or(diff, vec256_xor(s0[i], s1[i]));
135
136 return vec256_testz(diff);
137 }
138
139 static void reformat_128to256(vec256 * out, vec128 * in)
140 {
141 int i;
142 uint64_t v[4];
143
144 for (i = 0; i < 32; i++)
145 {
146 v[0] = vec128_extract(in[2*i+0], 0);
147 v[1] = vec128_extract(in[2*i+0], 1);
148 v[2] = vec128_extract(in[2*i+1], 0);
149 v[3] = vec128_extract(in[2*i+1], 1);
150
151 out[i] = vec256_set4x(v[0], v[1], v[2], v[3]);
152 }
153 }
154
155 static void reformat_256to128(vec128 * out, vec256 * in)
156 {
157 int i;
158 uint64_t v[4];
159
160 for (i = 0; i < 32; i++)
161 {
162 v[0] = vec256_extract(in[i], 0);
163 v[1] = vec256_extract(in[i], 1);
164 v[2] = vec256_extract(in[i], 2);
165 v[3] = vec256_extract(in[i], 3);
166
167 out[2*i+0] = vec128_set2x(v[0], v[1]);
168 out[2*i+1] = vec128_set2x(v[2], v[3]);
169 }
170 }
171
172 /* Niederreiter decryption with the Berlekamp decoder */
173 /* intput: sk, secret key */
174 /* s, ciphertext (syndrome) */
175 /* output: e, error vector */
176 /* return: 0 for success; 1 for failure */
177 int decrypt(unsigned char *e, const unsigned char *sk, const unsigned char *s)
178 {
179 int i;
180
181 uint16_t check_synd;
182 uint16_t check_weight;
183
184 vec256 inv[ 32 ][ GFBITS ];
185 vec256 scaled[ 32 ][ GFBITS ];
186 vec256 eval[32][ GFBITS ];
187
188 vec128 error128[ 64 ];
189 vec256 error256[ 32 ];
190
191 vec256 s_priv[ GFBITS ];
192 vec256 s_priv_cmp[ GFBITS ];
193 vec128 locator[ GFBITS ];
194
195 vec128 recv128[ 64 ];
196 vec256 recv256[ 32 ];
197 vec256 allone;
198
199 vec128 bits_int[25][32];
200
201 // Berlekamp decoder
202
203 preprocess(recv128, s);
204
205 load_bits(bits_int, sk + IRR_BYTES);
206 benes(recv128, bits_int, 1);
207
208 reformat_128to256(recv256, recv128);
209
210 scaling(scaled, inv, sk, recv256);
211 fft_tr(s_priv, scaled);
212 bm(locator, s_priv);
213
214 fft(eval, locator);
215
216 // reencryption and weight check
217
218 allone = vec256_set1_16b(0xFFFF);
219
220 for (i = 0; i < 32; i++)
221 {
222 error256[i] = vec256_or_reduce(eval[i]);
223 error256[i] = vec256_xor(error256[i], allone);
224 }
225
226 scaling_inv(scaled, inv, error256);
227 fft_tr(s_priv_cmp, scaled);
228
229 check_synd = synd_cmp(s_priv, s_priv_cmp);
230
231 //
232
233 reformat_256to128(error128, error256);
234 benes(error128, bits_int, 0);
235
236 postprocess(e, error128);
237
238 check_weight = weight_check(e, error128);
239
240 return 1 - (check_synd & check_weight);
241 }
242