Coverage Report

Created: 2026-11-15 06:55

next uncovered line (L), next uncovered region (R), next uncovered branch (B)
/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
}