Debian Codegraph @

crypto_kem/6688128f/vec/decrypt.c

raw
1 /*
2 This file is for Niederreiter decryption
3 */
4 // 20240805 djb: more cryptoint 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 vec_mul vec_sq vec_inv
11
12 #include "decrypt.h"
13
14 #include "params.h"
15 #include "fft_tr.h"
16 #include "benes.h"
17 #include "util.h"
18 #include "fft.h"
19 #include "vec.h"
20 #include "bm.h"
21
22 #include "crypto_int16.h"
23 #include "crypto_int8.h"
24 #include "crypto_int64.h"
25
26 static void scaling(vec out[][GFBITS], vec inv[][GFBITS], const unsigned char *sk, vec *recv)
27 {
28 int i, j;
29
30 vec irr_int[2][ GFBITS ];
31 vec eval[128][ GFBITS ];
32 vec tmp[ GFBITS ];
33
34 //
35
36 irr_load(irr_int, sk);
37
38 fft(eval, irr_int);
39
40 for (i = 0; i < 128; i++)
41 vec_sq(eval[i], eval[i]);
42
43 vec_copy(inv[0], eval[0]);
44
45 for (i = 1; i < 128; i++)
46 vec_mul(inv[i], inv[i-1], eval[i]);
47
48 vec_inv(tmp, inv[127]);
49
50 for (i = 126; i >= 0; i--)
51 {
52 vec_mul(inv[i+1], tmp, inv[i]);
53 vec_mul(tmp, tmp, eval[i+1]);
54 }
55
56 vec_copy(inv[0], tmp);
57
58 //
59
60 for (i = 0; i < 128; i++)
61 for (j = 0; j < GFBITS; j++)
62 out[i][j] = inv[i][j] & recv[i];
63 }
64
65 static void preprocess(vec *recv, const unsigned char *s)
66 {
67 int i;
68 unsigned char r[ 1024 ];
69
70 for (i = 0; i < SYND_BYTES; i++)
71 r[i] = s[i];
72
73 for (i = SYND_BYTES; i < 1024; i++)
74 r[i] = 0;
75
76 for (i = 0; i < 128; i++)
77 recv[i] = load8(r + i*8);
78 }
79
80 static void postprocess(unsigned char * e, vec * err)
81 {
82 int i;
83 unsigned char error8[ (1 << GFBITS)/8 ];
84
85 for (i = 0; i < 128; i++)
86 store8(error8 + i*8, err[i]);
87
88 for (i = 0; i < SYS_N/8; i++)
89 e[i] = error8[i];
90 }
91
92 static void scaling_inv(vec out[][GFBITS], vec inv[][GFBITS], vec *recv)
93 {
94 int i, j;
95
96 for (i = 0; i < 128; i++)
97 for (j = 0; j < GFBITS; j++)
98 out[i][j] = inv[i][j] & recv[i];
99 }
100
101 static int weight_check(unsigned char * e, vec * error)
102 {
103 int i;
104 uint16_t w0 = 0;
105 uint16_t w1 = 0;
106 uint16_t check;
107
108 for (i = 0; i < (1 << GFBITS); i++)
109 w0 += crypto_int64_bitmod_01(error[i/64], i);
110
111 for (i = 0; i < SYS_N; i++)
112 w1 += crypto_int8_bitmod_01(e[i/8], i);
113
114 check = (w0 ^ SYS_T) | (w1 ^ SYS_T);
115 return -crypto_int16_zero_mask(check);
116 }
117
118 static uint16_t synd_cmp(vec s0[][ GFBITS ] , vec s1[][ GFBITS ])
119 {
120 int i, j;
121 vec diff = 0;
122
123 for (i = 0; i < 4; i++)
124 for (j = 0; j < GFBITS; j++)
125 diff |= (s0[i][j] ^ s1[i][j]);
126
127 return vec_testz(diff);
128 }
129
130 /* Niederreiter decryption with the Berlekamp decoder */
131 /* intput: sk, secret key */
132 /* s, ciphertext (syndrome) */
133 /* output: e, error vector */
134 /* return: 0 for success; 1 for failure */
135 int decrypt(unsigned char *e, const unsigned char *sk, const unsigned char *s)
136 {
137 int i;
138
139 uint16_t check_synd;
140 uint16_t check_weight;
141
142 vec inv[ 128 ][ GFBITS ];
143 vec scaled[ 128 ][ GFBITS ];
144 vec eval[ 128 ][ GFBITS ];
145
146 vec error[ 128 ];
147
148 vec s_priv[ 4 ][ GFBITS ];
149 vec s_priv_cmp[ 4 ][ GFBITS ];
150 vec locator[2][ GFBITS ];
151
152 vec recv[ 128 ];
153 vec allone;
154
155 // Berlekamp decoder
156
157 preprocess(recv, s);
158
159 benes(recv, sk + IRR_BYTES, 1);
160 scaling(scaled, inv, sk, recv);
161 fft_tr(s_priv, scaled);
162 bm(locator, s_priv);
163
164 fft(eval, locator);
165
166 // reencryption and weight check
167
168 allone = vec_setbits(1);
169
170 for (i = 0; i < 128; i++)
171 {
172 error[i] = vec_or_reduce(eval[i]);
173 error[i] ^= allone;
174 }
175
176 scaling_inv(scaled, inv, error);
177 fft_tr(s_priv_cmp, scaled);
178
179 check_synd = synd_cmp(s_priv, s_priv_cmp);
180
181 //
182
183 benes(error, sk + IRR_BYTES, 0);
184
185 postprocess(e, error);
186
187 check_weight = weight_check(e, error);
188
189 return 1 - (check_synd & check_weight);
190 }
191