Debian Codegraph @

crypto_kem/8192128pcf/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 scaling_inv(vec256 out[][GFBITS], vec256 inv[][GFBITS], vec256 *recv)
64 {
65 int i, j;
66
67 for (i = 0; i < 32; i++)
68 for (j = 0; j < GFBITS; j++)
69 out[i][j] = vec256_and(inv[i][j], recv[i]);
70 }
71
72 static void preprocess(vec128 *recv, const unsigned char *s)
73 {
74 int i;
75
76 recv[0] = vec128_setbits(0);
77
78 for (i = 1; i < 64; i++)
79 recv[i] = recv[0];
80
81 for (i = 0; i < SYND_BYTES/16; i++)
82 recv[i] = load16(s + i*16);
83 }
84
85 static int weight(vec256 *v)
86 {
87 int i, w = 0;
88
89 for (i = 0; i < 32; i++)
90 {
91 w += __builtin_popcountll( vec256_extract(v[i], 0) );
92 w += __builtin_popcountll( vec256_extract(v[i], 1) );
93 w += __builtin_popcountll( vec256_extract(v[i], 2) );
94 w += __builtin_popcountll( vec256_extract(v[i], 3) );
95 }
96
97 return w;
98 }
99
100 static uint64_t synd_cmp(vec256 *s0 , vec256 *s1)
101 {
102 int i;
103 vec256 diff;
104
105 diff = vec256_xor(s0[0], s1[0]);
106
107 for (i = 1; i < GFBITS; i++)
108 diff = vec256_or(diff, vec256_xor(s0[i], s1[i]));
109
110 return vec256_testz(diff);
111 }
112
113 static void reformat_128to256(vec256 * out, vec128 * in)
114 {
115 int i;
116 uint64_t v[4];
117
118 for (i = 0; i < 32; i++)
119 {
120 v[0] = vec128_extract(in[2*i+0], 0);
121 v[1] = vec128_extract(in[2*i+0], 1);
122 v[2] = vec128_extract(in[2*i+1], 0);
123 v[3] = vec128_extract(in[2*i+1], 1);
124
125 out[i] = vec256_set4x(v[0], v[1], v[2], v[3]);
126 }
127 }
128
129 static void reformat_256to128(vec128 * out, vec256 * in)
130 {
131 int i;
132 uint64_t v[4];
133
134 for (i = 0; i < 32; i++)
135 {
136 v[0] = vec256_extract(in[i], 0);
137 v[1] = vec256_extract(in[i], 1);
138 v[2] = vec256_extract(in[i], 2);
139 v[3] = vec256_extract(in[i], 3);
140
141 out[2*i+0] = vec128_set2x(v[0], v[1]);
142 out[2*i+1] = vec128_set2x(v[2], v[3]);
143 }
144 }
145
146 /* Niederreiter decryption with the Berlekamp decoder */
147 /* intput: sk, secret key */
148 /* s, ciphertext (syndrome) */
149 /* output: e, error vector */
150 /* return: 0 for success; 1 for failure */
151 int decrypt(unsigned char *e, const unsigned char *sk, const unsigned char *s)
152 {
153 int i;
154
155 uint16_t check_synd;
156 uint16_t check_weight;
157
158 vec256 inv[ 64 ][ GFBITS ];
159 vec256 scaled[ 64 ][ GFBITS ];
160 vec256 eval[ 64 ][ GFBITS ];
161
162 vec128 error128[ 64 ];
163 vec256 error256[ 32 ];
164
165 vec256 s_priv[ GFBITS ];
166 vec256 s_priv_cmp[ GFBITS ];
167 vec128 locator[ GFBITS ];
168
169 vec128 recv128[ 64 ];
170 vec256 recv256[ 32 ];
171 vec256 allone;
172
173 vec128 bits_int[25][32];
174
175 // Berlekamp decoder
176
177 preprocess(recv128, s);
178
179 load_bits(bits_int, sk + IRR_BYTES);
180 benes(recv128, bits_int, 1);
181 reformat_128to256(recv256, recv128);
182
183 scaling(scaled, inv, sk, recv256); // scaling
184 fft_tr(s_priv, scaled); // transposed FFT
185 bm(locator, s_priv); // Berlekamp Massey
186
187 fft(eval, locator); // FFT
188
189 // reencryption and weight check
190
191 allone = vec256_set1_16b(0xFFFF);
192
193 for (i = 0; i < 32; i++)
194 {
195 error256[i] = vec256_or_reduce(eval[i]);
196 error256[i] = vec256_xor(error256[i], allone);
197 }
198
199 check_weight = weight(error256) ^ SYS_T;
200 check_weight = crypto_int16_zero_01(check_weight);
201
202 scaling_inv(scaled, inv, error256);
203 fft_tr(s_priv_cmp, scaled);
204
205 check_synd = synd_cmp(s_priv, s_priv_cmp);
206
207 //
208
209 reformat_256to128(error128, error256);
210 benes(error128, bits_int, 0);
211
212 for (i = 0; i < 64; i++)
213 store16(e + i*16, error128[i]);
214
215 return 1 - (check_synd & check_weight);
216 }
217