/src/nss/lib/freebl/kyber.c
Line | Count | Source |
1 | | /* This Source Code Form is subject to the terms of the Mozilla Public |
2 | | * License, v. 2.0. If a copy of the MPL was not distributed with this |
3 | | * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ |
4 | | |
5 | | #ifdef FREEBL_NO_DEPEND |
6 | | #include "stubs.h" |
7 | | #endif |
8 | | |
9 | | #include <stdbool.h> |
10 | | |
11 | | #include "blapi.h" |
12 | | #include "secerr.h" |
13 | | #include "secitem.h" |
14 | | |
15 | | #include "kyber.h" |
16 | | /* Vendored libcrux ML-KEM, from the combined ML-KEM + ML-DSA extraction in |
17 | | * lib/freebl/libcrux/ (shares its SHA-3/core with ml_dsa.c). Compiled into the |
18 | | * 'crux' static library; see lib/freebl/libcrux/README.md and the freebl build |
19 | | * files for the isolated include scope. */ |
20 | | #include "libcrux_mlkem512.h" |
21 | | #include "libcrux_mlkem512_portable.h" |
22 | | #include "libcrux_mlkem768.h" |
23 | | #include "libcrux_mlkem768_portable.h" |
24 | | #include "libcrux_mlkem1024.h" |
25 | | #include "libcrux_mlkem1024_portable.h" |
26 | | |
27 | | /* Local names for the libcrux entry point types that eurydice does not give a |
28 | | * stable name to: the trailing hash on Eurydice_arr_* and tuple_* is |
29 | | * regenerated by every extraction, so a re-vendor only has to update this block |
30 | | * rather than each use below. The keys have stable upstream names and are used |
31 | | * directly. */ |
32 | | typedef Eurydice_arr_c7 MlKemKeypairCoins; /* uint8_t[64] */ |
33 | | typedef Eurydice_arr_ec MlKemEncCoins; /* uint8_t[32] */ |
34 | | typedef Eurydice_arr_ec MlKemSharedSecret; /* uint8_t[32] */ |
35 | | typedef Eurydice_arr_d2 MlKem512Ciphertext; /* uint8_t[768] */ |
36 | | typedef Eurydice_arr_2b MlKem768Ciphertext; /* uint8_t[1088] */ |
37 | | typedef Eurydice_arr_d1 MlKem1024Ciphertext; /* uint8_t[1568] */ |
38 | | typedef tuple_ab MlKem512Encapsulation; /* { MlKem512Ciphertext fst; MlKemSharedSecret snd; } */ |
39 | | typedef tuple_f4 MlKem768Encapsulation; /* { MlKem768Ciphertext fst; MlKemSharedSecret snd; } */ |
40 | | typedef tuple_25 MlKem1024Encapsulation; /* { MlKem1024Ciphertext fst; MlKemSharedSecret snd; } */ |
41 | | |
42 | | /* Consistency check between the vendored libcrux array types and kyber.h. The |
43 | | * key/ciphertext/coin lengths are the sizes of the Eurydice_arr_* structs the |
44 | | * libcrux entry points take and return; if a re-vendor changes a size these fail |
45 | | * loudly. */ |
46 | | PR_STATIC_ASSERT(MLKEM512_PUBLIC_KEY_BYTES == sizeof(((libcrux_ml_kem_mlkem512_MlKem512PublicKey *)0)->data)); |
47 | | PR_STATIC_ASSERT(MLKEM512_PRIVATE_KEY_BYTES == sizeof(((libcrux_ml_kem_mlkem512_MlKem512PrivateKey *)0)->data)); |
48 | | PR_STATIC_ASSERT(MLKEM512_CIPHERTEXT_BYTES == sizeof(((MlKem512Ciphertext *)0)->data)); |
49 | | PR_STATIC_ASSERT(KYBER768_PUBLIC_KEY_BYTES == sizeof(((libcrux_ml_kem_mlkem768_MlKem768PublicKey *)0)->data)); |
50 | | PR_STATIC_ASSERT(KYBER768_PRIVATE_KEY_BYTES == sizeof(((libcrux_ml_kem_mlkem768_MlKem768PrivateKey *)0)->data)); |
51 | | PR_STATIC_ASSERT(KYBER768_CIPHERTEXT_BYTES == sizeof(((MlKem768Ciphertext *)0)->data)); |
52 | | PR_STATIC_ASSERT(KYBER_SHARED_SECRET_BYTES == sizeof(((MlKemSharedSecret *)0)->data)); |
53 | | PR_STATIC_ASSERT(KYBER_KEYPAIR_COIN_BYTES == sizeof(((MlKemKeypairCoins *)0)->data)); |
54 | | PR_STATIC_ASSERT(KYBER_ENC_COIN_BYTES == sizeof(((MlKemEncCoins *)0)->data)); |
55 | | PR_STATIC_ASSERT(MLKEM1024_PUBLIC_KEY_BYTES == sizeof(((libcrux_ml_kem_mlkem1024_MlKem1024PublicKey *)0)->data)); |
56 | | PR_STATIC_ASSERT(MLKEM1024_PRIVATE_KEY_BYTES == sizeof(((libcrux_ml_kem_mlkem1024_MlKem1024PrivateKey *)0)->data)); |
57 | | PR_STATIC_ASSERT(MLKEM1024_CIPHERTEXT_BYTES == sizeof(((MlKem1024Ciphertext *)0)->data)); |
58 | | |
59 | | static bool |
60 | | valid_params(KyberParams params) |
61 | 13.8k | { |
62 | 13.8k | switch (params) { |
63 | 0 | case params_ml_kem512: |
64 | 0 | case params_ml_kem512_test_mode: |
65 | 13.3k | case params_ml_kem768: |
66 | 13.3k | case params_ml_kem768_test_mode: |
67 | 13.8k | case params_ml_kem1024: |
68 | 13.8k | case params_ml_kem1024_test_mode: |
69 | 13.8k | return true; |
70 | 0 | default: |
71 | 0 | return false; |
72 | 13.8k | } |
73 | 13.8k | } |
74 | | |
75 | | static bool |
76 | | valid_pubkey(KyberParams params, const SECItem *pubkey) |
77 | 13.7k | { |
78 | 13.7k | switch (params) { |
79 | 0 | case params_ml_kem512: |
80 | 0 | case params_ml_kem512_test_mode: |
81 | 0 | return pubkey && pubkey->len == MLKEM512_PUBLIC_KEY_BYTES; |
82 | 13.2k | case params_ml_kem768: |
83 | 13.2k | case params_ml_kem768_test_mode: |
84 | 13.2k | return pubkey && pubkey->len == KYBER768_PUBLIC_KEY_BYTES; |
85 | 492 | case params_ml_kem1024: |
86 | 492 | case params_ml_kem1024_test_mode: |
87 | 492 | return pubkey && pubkey->len == MLKEM1024_PUBLIC_KEY_BYTES; |
88 | 0 | default: |
89 | 0 | return false; |
90 | 13.7k | } |
91 | 13.7k | } |
92 | | |
93 | | static bool |
94 | | valid_privkey(KyberParams params, const SECItem *privkey) |
95 | 13.0k | { |
96 | 13.0k | switch (params) { |
97 | 0 | case params_ml_kem512: |
98 | 0 | case params_ml_kem512_test_mode: |
99 | 0 | return privkey && privkey->len == MLKEM512_PRIVATE_KEY_BYTES; |
100 | 13.0k | case params_ml_kem768: |
101 | 13.0k | case params_ml_kem768_test_mode: |
102 | 13.0k | return privkey && privkey->len == KYBER768_PRIVATE_KEY_BYTES; |
103 | 53 | case params_ml_kem1024: |
104 | 53 | case params_ml_kem1024_test_mode: |
105 | 53 | return privkey && privkey->len == MLKEM1024_PRIVATE_KEY_BYTES; |
106 | 0 | default: |
107 | 0 | return false; |
108 | 13.0k | } |
109 | 13.0k | } |
110 | | |
111 | | static bool |
112 | | valid_ciphertext(KyberParams params, const SECItem *ciphertext) |
113 | 909 | { |
114 | 909 | switch (params) { |
115 | 0 | case params_ml_kem512: |
116 | 0 | case params_ml_kem512_test_mode: |
117 | 0 | return ciphertext && ciphertext->len == MLKEM512_CIPHERTEXT_BYTES; |
118 | 470 | case params_ml_kem768: |
119 | 470 | case params_ml_kem768_test_mode: |
120 | 470 | return ciphertext && ciphertext->len == KYBER768_CIPHERTEXT_BYTES; |
121 | 439 | case params_ml_kem1024: |
122 | 439 | case params_ml_kem1024_test_mode: |
123 | 439 | return ciphertext && ciphertext->len == MLKEM1024_CIPHERTEXT_BYTES; |
124 | 0 | default: |
125 | 0 | return false; |
126 | 909 | } |
127 | 909 | } |
128 | | |
129 | | static bool |
130 | | valid_secret(KyberParams params, const SECItem *secret) |
131 | 909 | { |
132 | 909 | switch (params) { |
133 | 0 | case params_ml_kem512: |
134 | 0 | case params_ml_kem512_test_mode: |
135 | 470 | case params_ml_kem768: |
136 | 470 | case params_ml_kem768_test_mode: |
137 | 909 | case params_ml_kem1024: |
138 | 909 | case params_ml_kem1024_test_mode: |
139 | 909 | return secret && secret->len == KYBER_SHARED_SECRET_BYTES; |
140 | 0 | default: |
141 | 0 | return false; |
142 | 909 | } |
143 | 909 | } |
144 | | |
145 | | static bool |
146 | | valid_keypair_seed(KyberParams params, const SECItem *seed) |
147 | 12.9k | { |
148 | 12.9k | switch (params) { |
149 | 0 | case params_ml_kem512: |
150 | 0 | case params_ml_kem512_test_mode: |
151 | 12.9k | case params_ml_kem768: |
152 | 12.9k | case params_ml_kem768_test_mode: |
153 | 12.9k | case params_ml_kem1024: |
154 | 12.9k | case params_ml_kem1024_test_mode: |
155 | 12.9k | return !seed || seed->len == KYBER_KEYPAIR_COIN_BYTES; |
156 | 0 | default: |
157 | 0 | return false; |
158 | 12.9k | } |
159 | 12.9k | } |
160 | | |
161 | | static bool |
162 | | valid_enc_seed(KyberParams params, const SECItem *seed) |
163 | 784 | { |
164 | 784 | switch (params) { |
165 | | /* Only the test-mode parameter sets accept caller-supplied |
166 | | * encapsulation randomness; everywhere else it must come from the |
167 | | * RNG. */ |
168 | 0 | case params_ml_kem512: |
169 | 345 | case params_ml_kem768: |
170 | 784 | case params_ml_kem1024: |
171 | 784 | return !seed; |
172 | 0 | case params_ml_kem512_test_mode: |
173 | 0 | case params_ml_kem768_test_mode: |
174 | 0 | case params_ml_kem1024_test_mode: |
175 | 0 | return !seed || seed->len == KYBER_ENC_COIN_BYTES; |
176 | 0 | default: |
177 | 0 | return false; |
178 | 784 | } |
179 | 784 | } |
180 | | |
181 | | SECStatus |
182 | | Kyber_NewKey(KyberParams params, const SECItem *keypair_seed, SECItem *privkey, SECItem *pubkey) |
183 | 12.9k | { |
184 | 12.9k | if (!valid_params(params)) { |
185 | 0 | PORT_SetError(SEC_ERROR_INVALID_ALGORITHM); |
186 | 0 | return SECFailure; |
187 | 0 | } |
188 | | |
189 | 12.9k | if (!(valid_keypair_seed(params, keypair_seed) && valid_privkey(params, privkey) && valid_pubkey(params, pubkey))) { |
190 | 0 | PORT_SetError(SEC_ERROR_INVALID_ARGS); |
191 | 0 | return SECFailure; |
192 | 0 | } |
193 | | |
194 | 12.9k | uint8_t randbuf[KYBER_KEYPAIR_COIN_BYTES]; |
195 | 12.9k | uint8_t *coins; |
196 | 12.9k | if (keypair_seed) { |
197 | 12.9k | coins = keypair_seed->data; |
198 | 12.9k | } else { |
199 | 0 | if (RNG_GenerateGlobalRandomBytes(randbuf, sizeof randbuf) != SECSuccess) { |
200 | 0 | PORT_SetError(SEC_ERROR_NEED_RANDOM); |
201 | 0 | return SECFailure; |
202 | 0 | } |
203 | 0 | coins = randbuf; |
204 | 0 | } |
205 | 12.9k | NSS_CLASSIFY(coins, KYBER_KEYPAIR_COIN_BYTES); |
206 | 12.9k | if (params == params_ml_kem512 || params == params_ml_kem512_test_mode) { |
207 | 0 | MlKemKeypairCoins coinsArr; |
208 | 0 | memcpy(coinsArr.data, coins, KYBER_KEYPAIR_COIN_BYTES); |
209 | 0 | libcrux_ml_kem_mlkem512_MlKem512KeyPair keys = libcrux_ml_kem_mlkem512_portable_generate_key_pair(coinsArr); |
210 | 0 | memcpy(pubkey->data, keys.pk.data, MLKEM512_PUBLIC_KEY_BYTES); |
211 | 0 | memcpy(privkey->data, keys.sk.data, MLKEM512_PRIVATE_KEY_BYTES); |
212 | 12.9k | } else if (params == params_ml_kem768 || params == params_ml_kem768_test_mode) { |
213 | 12.9k | MlKemKeypairCoins coinsArr; |
214 | 12.9k | memcpy(coinsArr.data, coins, KYBER_KEYPAIR_COIN_BYTES); |
215 | 12.9k | libcrux_ml_kem_mlkem768_MlKem768KeyPair keys = libcrux_ml_kem_mlkem768_portable_generate_key_pair(coinsArr); |
216 | 12.9k | memcpy(pubkey->data, keys.pk.data, KYBER768_PUBLIC_KEY_BYTES); |
217 | 12.9k | memcpy(privkey->data, keys.sk.data, KYBER768_PRIVATE_KEY_BYTES); |
218 | 12.9k | } else if (params == params_ml_kem1024 || params == params_ml_kem1024_test_mode) { |
219 | 53 | MlKemKeypairCoins coinsArr; |
220 | 53 | memcpy(coinsArr.data, coins, KYBER_KEYPAIR_COIN_BYTES); |
221 | 53 | libcrux_ml_kem_mlkem1024_MlKem1024KeyPair keys = libcrux_ml_kem_mlkem1024_portable_generate_key_pair(coinsArr); |
222 | 53 | memcpy(pubkey->data, keys.pk.data, MLKEM1024_PUBLIC_KEY_BYTES); |
223 | 53 | memcpy(privkey->data, keys.sk.data, MLKEM1024_PRIVATE_KEY_BYTES); |
224 | 53 | } else { |
225 | | /* round-3 Kyber removed; only ML-KEM is supported */ |
226 | 0 | PORT_SetError(SEC_ERROR_INVALID_ALGORITHM); |
227 | 0 | return SECFailure; |
228 | 0 | } |
229 | 12.9k | NSS_DECLASSIFY(pubkey->data, pubkey->len); |
230 | 12.9k | return SECSuccess; |
231 | 12.9k | } |
232 | | |
233 | | SECStatus |
234 | | Kyber_Encapsulate(KyberParams params, const SECItem *enc_seed, const SECItem *pubkey, SECItem *ciphertext, SECItem *secret) |
235 | 784 | { |
236 | 784 | if (!valid_params(params)) { |
237 | 0 | PORT_SetError(SEC_ERROR_INVALID_ALGORITHM); |
238 | 0 | return SECFailure; |
239 | 0 | } |
240 | | |
241 | 784 | if (!(valid_enc_seed(params, enc_seed) && valid_pubkey(params, pubkey) && valid_ciphertext(params, ciphertext) && valid_secret(params, secret))) { |
242 | 0 | PORT_SetError(SEC_ERROR_INVALID_ARGS); |
243 | 0 | return SECFailure; |
244 | 0 | } |
245 | | |
246 | 784 | uint8_t randbuf[KYBER_ENC_COIN_BYTES]; |
247 | 784 | uint8_t *coins; |
248 | 784 | if (enc_seed) { |
249 | 0 | coins = enc_seed->data; |
250 | 784 | } else { |
251 | 784 | if (RNG_GenerateGlobalRandomBytes(randbuf, sizeof randbuf) != SECSuccess) { |
252 | 0 | PORT_SetError(SEC_ERROR_NEED_RANDOM); |
253 | 0 | return SECFailure; |
254 | 0 | } |
255 | 784 | coins = randbuf; |
256 | 784 | } |
257 | 784 | NSS_CLASSIFY(coins, KYBER_ENC_COIN_BYTES); |
258 | 784 | if (params == params_ml_kem512 || params == params_ml_kem512_test_mode) { |
259 | 0 | libcrux_ml_kem_mlkem512_MlKem512PublicKey pk_value; |
260 | 0 | memcpy(pk_value.data, pubkey->data, MLKEM512_PUBLIC_KEY_BYTES); |
261 | |
|
262 | 0 | bool valid_pk = libcrux_ml_kem_mlkem512_portable_validate_public_key(&pk_value); |
263 | 0 | if (!valid_pk) { |
264 | 0 | PORT_SetError(SEC_ERROR_INVALID_ARGS); |
265 | 0 | return SECFailure; |
266 | 0 | } |
267 | | |
268 | 0 | MlKemEncCoins coinsArr; |
269 | 0 | memcpy(coinsArr.data, coins, KYBER_ENC_COIN_BYTES); |
270 | 0 | MlKem512Encapsulation encap = libcrux_ml_kem_mlkem512_portable_encapsulate(&pk_value, coinsArr); |
271 | 0 | memcpy(ciphertext->data, encap.fst.data, MLKEM512_CIPHERTEXT_BYTES); |
272 | 0 | memcpy(secret->data, encap.snd.data, KYBER_SHARED_SECRET_BYTES); |
273 | 784 | } else if (params == params_ml_kem768 || params == params_ml_kem768_test_mode) { |
274 | 345 | libcrux_ml_kem_mlkem768_MlKem768PublicKey pk_value; |
275 | 345 | memcpy(pk_value.data, pubkey->data, KYBER768_PUBLIC_KEY_BYTES); |
276 | | |
277 | 345 | bool valid_pk = libcrux_ml_kem_mlkem768_portable_validate_public_key(&pk_value); |
278 | 345 | if (!valid_pk) { |
279 | 86 | PORT_SetError(SEC_ERROR_INVALID_ARGS); |
280 | 86 | return SECFailure; |
281 | 86 | } |
282 | | |
283 | 259 | MlKemEncCoins coinsArr; |
284 | 259 | memcpy(coinsArr.data, coins, KYBER_ENC_COIN_BYTES); |
285 | 259 | MlKem768Encapsulation encap = libcrux_ml_kem_mlkem768_portable_encapsulate(&pk_value, coinsArr); |
286 | 259 | memcpy(ciphertext->data, encap.fst.data, KYBER768_CIPHERTEXT_BYTES); |
287 | 259 | memcpy(secret->data, encap.snd.data, KYBER_SHARED_SECRET_BYTES); |
288 | 439 | } else if (params == params_ml_kem1024 || params == params_ml_kem1024_test_mode) { |
289 | 439 | libcrux_ml_kem_mlkem1024_MlKem1024PublicKey pk_value; |
290 | 439 | memcpy(pk_value.data, pubkey->data, MLKEM1024_PUBLIC_KEY_BYTES); |
291 | | |
292 | 439 | bool valid_pk = libcrux_ml_kem_mlkem1024_portable_validate_public_key(&pk_value); |
293 | 439 | if (!valid_pk) { |
294 | 88 | PORT_SetError(SEC_ERROR_INVALID_ARGS); |
295 | 88 | return SECFailure; |
296 | 88 | } |
297 | | |
298 | 351 | MlKemEncCoins coinsArr; |
299 | 351 | memcpy(coinsArr.data, coins, KYBER_ENC_COIN_BYTES); |
300 | 351 | MlKem1024Encapsulation encap = libcrux_ml_kem_mlkem1024_portable_encapsulate(&pk_value, coinsArr); |
301 | 351 | memcpy(ciphertext->data, encap.fst.data, MLKEM1024_CIPHERTEXT_BYTES); |
302 | 351 | memcpy(secret->data, encap.snd.data, KYBER_SHARED_SECRET_BYTES); |
303 | 351 | } else { |
304 | | /* round-3 Kyber removed; only ML-KEM is supported */ |
305 | 0 | PORT_SetError(SEC_ERROR_INVALID_ALGORITHM); |
306 | 0 | return SECFailure; |
307 | 0 | } |
308 | | |
309 | 610 | return SECSuccess; |
310 | 784 | } |
311 | | |
312 | | SECStatus |
313 | | Kyber_Decapsulate(KyberParams params, const SECItem *privkey, const SECItem *ciphertext, SECItem *secret) |
314 | 125 | { |
315 | 125 | if (!valid_params(params)) { |
316 | 0 | PORT_SetError(SEC_ERROR_INVALID_ALGORITHM); |
317 | 0 | return SECFailure; |
318 | 0 | } |
319 | | |
320 | 125 | if (!(valid_privkey(params, privkey) && valid_ciphertext(params, ciphertext) && valid_secret(params, secret))) { |
321 | 0 | PORT_SetError(SEC_ERROR_INVALID_ARGS); |
322 | 0 | return SECFailure; |
323 | 0 | } |
324 | | |
325 | 125 | if (params == params_ml_kem512 || params == params_ml_kem512_test_mode) { |
326 | 0 | libcrux_ml_kem_mlkem512_MlKem512PrivateKey private_key; |
327 | 0 | memcpy(private_key.data, privkey->data, MLKEM512_PRIVATE_KEY_BYTES); |
328 | |
|
329 | 0 | MlKem512Ciphertext cipher_text; |
330 | 0 | memcpy(cipher_text.data, ciphertext->data, MLKEM512_CIPHERTEXT_BYTES); |
331 | |
|
332 | 0 | bool valid = libcrux_ml_kem_mlkem512_portable_validate_private_key(&private_key, &cipher_text); |
333 | 0 | if (!valid) { |
334 | 0 | PORT_SetError(SEC_ERROR_INVALID_ARGS); |
335 | 0 | return SECFailure; |
336 | 0 | } |
337 | | |
338 | 0 | MlKemSharedSecret ss = libcrux_ml_kem_mlkem512_portable_decapsulate(&private_key, &cipher_text); |
339 | 0 | memcpy(secret->data, ss.data, KYBER_SHARED_SECRET_BYTES); |
340 | 125 | } else if (params == params_ml_kem768 || params == params_ml_kem768_test_mode) { |
341 | 125 | libcrux_ml_kem_mlkem768_MlKem768PrivateKey private_key; |
342 | 125 | memcpy(private_key.data, privkey->data, KYBER768_PRIVATE_KEY_BYTES); |
343 | | |
344 | 125 | MlKem768Ciphertext cipher_text; |
345 | 125 | memcpy(cipher_text.data, ciphertext->data, KYBER768_CIPHERTEXT_BYTES); |
346 | | |
347 | 125 | bool valid = libcrux_ml_kem_mlkem768_portable_validate_private_key(&private_key, &cipher_text); |
348 | 125 | if (!valid) { |
349 | 0 | PORT_SetError(SEC_ERROR_INVALID_ARGS); |
350 | 0 | return SECFailure; |
351 | 0 | } |
352 | | |
353 | 125 | MlKemSharedSecret ss = libcrux_ml_kem_mlkem768_portable_decapsulate(&private_key, &cipher_text); |
354 | 125 | memcpy(secret->data, ss.data, KYBER_SHARED_SECRET_BYTES); |
355 | 125 | } else if (params == params_ml_kem1024 || params == params_ml_kem1024_test_mode) { |
356 | 0 | libcrux_ml_kem_mlkem1024_MlKem1024PrivateKey private_key; |
357 | 0 | memcpy(private_key.data, privkey->data, MLKEM1024_PRIVATE_KEY_BYTES); |
358 | |
|
359 | 0 | MlKem1024Ciphertext cipher_text; |
360 | 0 | memcpy(cipher_text.data, ciphertext->data, MLKEM1024_CIPHERTEXT_BYTES); |
361 | |
|
362 | 0 | bool valid = libcrux_ml_kem_mlkem1024_portable_validate_private_key(&private_key, &cipher_text); |
363 | 0 | if (!valid) { |
364 | 0 | PORT_SetError(SEC_ERROR_INVALID_ARGS); |
365 | 0 | return SECFailure; |
366 | 0 | } |
367 | | |
368 | 0 | MlKemSharedSecret ss = libcrux_ml_kem_mlkem1024_portable_decapsulate(&private_key, &cipher_text); |
369 | 0 | memcpy(secret->data, ss.data, KYBER_SHARED_SECRET_BYTES); |
370 | 0 | } else { |
371 | | /* round-3 Kyber removed; only ML-KEM is supported */ |
372 | 0 | PORT_SetError(SEC_ERROR_INVALID_ALGORITHM); |
373 | 0 | return SECFailure; |
374 | 0 | } |
375 | | |
376 | 125 | return SECSuccess; |
377 | 125 | } |