feedc0de/wolfssl
1
0
Fork 0
forked from wolfSSL/wolfssl
Code Pull Requests Activity

Update wc_KyberKey API to wc_MlKem

Browse Source 
Co-Authored-By: sean@wolfssl.com <sean@wolfssl.com>
This commit is contained in:
Devin AI
2025-02-18 22:38:06 +00:00
parent 48f1c3b57d
commit 9079a6d44c
7 changed files with 202 additions and 202 deletions
Download Patch File Download Diff File Expand all files Collapse all files

46
src/tls.c
View File

@ -8133,7 +8133,7 @@ static int TLSX_KeyShare_GenPqcKey(WOLFSSL *ssl, KeyShareEntry* kse)
} }
if (ret == 0) { if (ret == 0) {
ret = wc_KyberKey_Init(type, kem, ssl->heap, ssl->devId); ret = wc_MlKem_Init(type, kem, ssl->heap, ssl->devId);
if (ret != 0) { if (ret != 0) {
WOLFSSL_MSG("Failed to initialize Kyber Key."); WOLFSSL_MSG("Failed to initialize Kyber Key.");
} }
@ -8151,10 +8151,10 @@ static int TLSX_KeyShare_GenPqcKey(WOLFSSL *ssl, KeyShareEntry* kse)
if (ret == 0) { if (ret == 0) {
XMEMSET(ecc_kse, 0, sizeof(*ecc_kse)); XMEMSET(ecc_kse, 0, sizeof(*ecc_kse));
ret = wc_KyberKey_PrivateKeySize(kem, &privSz); ret = wc_MlKem_PrivateKeySize(kem, &privSz);
} }
if (ret == 0) { if (ret == 0) {
ret = wc_KyberKey_PublicKeySize(kem, &pubSz); ret = wc_MlKem_PublicKeySize(kem, &pubSz);
} }
if (ret == 0 && ecc_group != 0) { if (ret == 0 && ecc_group != 0) {
@ -8181,17 +8181,17 @@ static int TLSX_KeyShare_GenPqcKey(WOLFSSL *ssl, KeyShareEntry* kse)
} }
if (ret == 0) { if (ret == 0) {
ret = wc_KyberKey_MakeKey(kem, ssl->rng); ret = wc_MlKem_MakeKey(kem, ssl->rng);
if (ret != 0) { if (ret != 0) {
WOLFSSL_MSG("Kyber keygen failure"); WOLFSSL_MSG("Kyber keygen failure");
} }
} }
if (ret == 0) { if (ret == 0) {
ret = wc_KyberKey_EncodePublicKey(kem, pubKey + ecc_kse->pubKeyLen, ret = wc_MlKem_EncodePublicKey(kem, pubKey + ecc_kse->pubKeyLen,
pubSz); pubSz);
} }
if (ret == 0) { if (ret == 0) {
ret = wc_KyberKey_EncodePrivateKey(kem, privKey, privSz); ret = wc_MlKem_EncodePrivateKey(kem, privKey, privSz);
} }
if (ret == 0) { if (ret == 0) {
if (ecc_kse->pubKeyLen > 0) if (ecc_kse->pubKeyLen > 0)
@ -8217,7 +8217,7 @@ static int TLSX_KeyShare_GenPqcKey(WOLFSSL *ssl, KeyShareEntry* kse)
WOLFSSL_BUFFER(kse->pubKey, kse->pubKeyLen ); WOLFSSL_BUFFER(kse->pubKey, kse->pubKeyLen );
#endif #endif
wc_KyberKey_Free(kem); wc_MlKem_Free(kem);
TLSX_KeyShare_FreeAll(ecc_kse, ssl->heap); TLSX_KeyShare_FreeAll(ecc_kse, ssl->heap);
XFREE(pubKey, ssl->heap, DYNAMIC_TYPE_PUBLIC_KEY); XFREE(pubKey, ssl->heap, DYNAMIC_TYPE_PUBLIC_KEY);
XFREE(privKey, ssl->heap, DYNAMIC_TYPE_PRIVATE_KEY); XFREE(privKey, ssl->heap, DYNAMIC_TYPE_PRIVATE_KEY);
@ -8887,7 +8887,7 @@ static int TLSX_KeyShare_ProcessPqc(WOLFSSL* ssl, KeyShareEntry* keyShareEntry)
return BAD_FUNC_ARG; return BAD_FUNC_ARG;
} }
ret = wc_KyberKey_Init(type, kem, ssl->heap, ssl->devId); ret = wc_MlKem_Init(type, kem, ssl->heap, ssl->devId);
if (ret != 0) { if (ret != 0) {
wc_ecc_free(&eccpubkey); wc_ecc_free(&eccpubkey);
WOLFSSL_MSG("Error creating Kyber KEM"); WOLFSSL_MSG("Error creating Kyber KEM");
@ -8895,7 +8895,7 @@ static int TLSX_KeyShare_ProcessPqc(WOLFSSL* ssl, KeyShareEntry* keyShareEntry)
} }
if (ret == 0) { if (ret == 0) {
ret = wc_KyberKey_SharedSecretSize(kem, &ssSz); ret = wc_MlKem_SharedSecretSize(kem, &ssSz);
} }
if (ret == 0) { if (ret == 0) {
sharedSecretLen = ssSz; sharedSecretLen = ssSz;
@ -8925,19 +8925,19 @@ static int TLSX_KeyShare_ProcessPqc(WOLFSSL* ssl, KeyShareEntry* keyShareEntry)
} }
} }
if (ret == 0) { if (ret == 0) {
ret = wc_KyberKey_CipherTextSize(kem, &ctSz); ret = wc_MlKem_CipherTextSize(kem, &ctSz);
} }
if (ret == 0) { if (ret == 0) {
ret = wc_KyberKey_PrivateKeySize(kem, &privSz); ret = wc_MlKem_PrivateKeySize(kem, &privSz);
} }
if (ret == 0) { if (ret == 0) {
ret = wc_KyberKey_DecodePrivateKey(kem, keyShareEntry->privKey, privSz); ret = wc_MlKem_DecodePrivateKey(kem, keyShareEntry->privKey, privSz);
} }
if (ret == 0) { if (ret == 0) {
ret = wc_KyberKey_Decapsulate(kem, sharedSecret + outlen, ret = wc_MlKem_Decapsulate(kem, sharedSecret + outlen,
keyShareEntry->ke + keyShareEntry->keLen - ctSz, ctSz); keyShareEntry->ke + keyShareEntry->keLen - ctSz, ctSz);
if (ret != 0) { if (ret != 0) {
WOLFSSL_MSG("wc_KyberKey decapsulation failure."); WOLFSSL_MSG("wc_MlKem decapsulation failure.");
ret = BAD_FUNC_ARG; ret = BAD_FUNC_ARG;
} }
} }
@ -8990,7 +8990,7 @@ static int TLSX_KeyShare_ProcessPqc(WOLFSSL* ssl, KeyShareEntry* keyShareEntry)
XFREE(sharedSecret, ssl->heap, DYNAMIC_TYPE_SECRET); XFREE(sharedSecret, ssl->heap, DYNAMIC_TYPE_SECRET);
wc_ecc_free(&eccpubkey); wc_ecc_free(&eccpubkey);
wc_KyberKey_Free(kem); wc_MlKem_Free(kem);
return ret; return ret;
} }
#endif /* WOLFSSL_HAVE_KYBER */ #endif /* WOLFSSL_HAVE_KYBER */
@ -9379,7 +9379,7 @@ static int server_generate_pqc_ciphertext(WOLFSSL* ssl,
return MEMORY_E; return MEMORY_E;
} }
ret = wc_KyberKey_Init(type, kem, ssl->heap, ssl->devId); ret = wc_MlKem_Init(type, kem, ssl->heap, ssl->devId);
if (ret != 0) { if (ret != 0) {
wc_ecc_free(&eccpubkey); wc_ecc_free(&eccpubkey);
WOLFSSL_MSG("Error creating Kyber KEM"); WOLFSSL_MSG("Error creating Kyber KEM");
@ -9406,13 +9406,13 @@ static int server_generate_pqc_ciphertext(WOLFSSL* ssl,
} }
if (ret == 0) { if (ret == 0) {
ret = wc_KyberKey_PublicKeySize(kem, &pubSz); ret = wc_MlKem_PublicKeySize(kem, &pubSz);
} }
if (ret == 0) { if (ret == 0) {
ret = wc_KyberKey_CipherTextSize(kem, &ctSz); ret = wc_MlKem_CipherTextSize(kem, &ctSz);
} }
if (ret == 0) { if (ret == 0) {
ret = wc_KyberKey_SharedSecretSize(kem, &ssSz); ret = wc_MlKem_SharedSecretSize(kem, &ssSz);
} }
if (ret == 0 && len != pubSz + ecc_kse->pubKeyLen) { if (ret == 0 && len != pubSz + ecc_kse->pubKeyLen) {
@ -9464,14 +9464,14 @@ static int server_generate_pqc_ciphertext(WOLFSSL* ssl,
} }
if (ret == 0) { if (ret == 0) {
ret = wc_KyberKey_DecodePublicKey(kem, data + ecc_kse->pubKeyLen, ret = wc_MlKem_DecodePublicKey(kem, data + ecc_kse->pubKeyLen,
pubSz); pubSz);
} }
if (ret == 0) { if (ret == 0) {
ret = wc_KyberKey_Encapsulate(kem, ciphertext + ecc_kse->pubKeyLen, ret = wc_MlKem_Encapsulate(kem, ciphertext + ecc_kse->pubKeyLen,
sharedSecret + outlen, ssl->rng); sharedSecret + outlen, ssl->rng);
if (ret != 0) { if (ret != 0) {
WOLFSSL_MSG("wc_KyberKey encapsulation failure."); WOLFSSL_MSG("wc_MlKem encapsulation failure.");
} }
} }
@ -9497,7 +9497,7 @@ static int server_generate_pqc_ciphertext(WOLFSSL* ssl,
XFREE(sharedSecret, ssl->heap, DYNAMIC_TYPE_SECRET); XFREE(sharedSecret, ssl->heap, DYNAMIC_TYPE_SECRET);
XFREE(ciphertext, ssl->heap, DYNAMIC_TYPE_TLSX); XFREE(ciphertext, ssl->heap, DYNAMIC_TYPE_TLSX);
wc_ecc_free(&eccpubkey); wc_ecc_free(&eccpubkey);
wc_KyberKey_Free(kem); wc_MlKem_Free(kem);
return ret; return ret;
} }
#endif /* WOLFSSL_HAVE_KYBER */ #endif /* WOLFSSL_HAVE_KYBER */

78
tests/api.c
View File

@ -26996,40 +26996,40 @@ static int test_wc_kyber_make_key_kats(void)
} }
#ifndef WOLFSSL_NO_ML_KEM_512 #ifndef WOLFSSL_NO_ML_KEM_512
ExpectIntEQ(wc_KyberKey_Init(WC_ML_KEM_512, key, NULL, INVALID_DEVID), 0); ExpectIntEQ(wc_MlKem_Init(WC_ML_KEM_512, key, NULL, INVALID_DEVID), 0);
ExpectIntEQ(wc_KyberKey_MakeKeyWithRandom(key, seed_512, sizeof(seed_512)), ExpectIntEQ(wc_MlKem_MakeKeyWithRandom(key, seed_512, sizeof(seed_512)),
0); 0);
ExpectIntEQ(wc_KyberKey_EncodePublicKey(key, pubKey, ExpectIntEQ(wc_MlKem_EncodePublicKey(key, pubKey,
WC_ML_KEM_512_PUBLIC_KEY_SIZE), 0); WC_ML_KEM_512_PUBLIC_KEY_SIZE), 0);
ExpectIntEQ(wc_KyberKey_EncodePrivateKey(key, privKey, ExpectIntEQ(wc_MlKem_EncodePrivateKey(key, privKey,
WC_ML_KEM_512_PRIVATE_KEY_SIZE), 0); WC_ML_KEM_512_PRIVATE_KEY_SIZE), 0);
ExpectIntEQ(XMEMCMP(pubKey, ek_512, WC_ML_KEM_512_PUBLIC_KEY_SIZE), 0); ExpectIntEQ(XMEMCMP(pubKey, ek_512, WC_ML_KEM_512_PUBLIC_KEY_SIZE), 0);
ExpectIntEQ(XMEMCMP(privKey, dk_512, WC_ML_KEM_512_PRIVATE_KEY_SIZE), 0); ExpectIntEQ(XMEMCMP(privKey, dk_512, WC_ML_KEM_512_PRIVATE_KEY_SIZE), 0);
wc_KyberKey_Free(key); wc_MlKem_Free(key);
#endif #endif
#ifndef WOLFSSL_NO_ML_KEM_768 #ifndef WOLFSSL_NO_ML_KEM_768
ExpectIntEQ(wc_KyberKey_Init(WC_ML_KEM_768, key, NULL, INVALID_DEVID), 0); ExpectIntEQ(wc_MlKem_Init(WC_ML_KEM_768, key, NULL, INVALID_DEVID), 0);
ExpectIntEQ(wc_KyberKey_MakeKeyWithRandom(key, seed_768, sizeof(seed_768)), ExpectIntEQ(wc_MlKem_MakeKeyWithRandom(key, seed_768, sizeof(seed_768)),
0); 0);
ExpectIntEQ(wc_KyberKey_EncodePublicKey(key, pubKey, ExpectIntEQ(wc_MlKem_EncodePublicKey(key, pubKey,
WC_ML_KEM_768_PUBLIC_KEY_SIZE), 0); WC_ML_KEM_768_PUBLIC_KEY_SIZE), 0);
ExpectIntEQ(wc_KyberKey_EncodePrivateKey(key, privKey, ExpectIntEQ(wc_MlKem_EncodePrivateKey(key, privKey,
WC_ML_KEM_768_PRIVATE_KEY_SIZE), 0); WC_ML_KEM_768_PRIVATE_KEY_SIZE), 0);
ExpectIntEQ(XMEMCMP(pubKey, ek_768, WC_ML_KEM_768_PUBLIC_KEY_SIZE), 0); ExpectIntEQ(XMEMCMP(pubKey, ek_768, WC_ML_KEM_768_PUBLIC_KEY_SIZE), 0);
ExpectIntEQ(XMEMCMP(privKey, dk_768, WC_ML_KEM_768_PRIVATE_KEY_SIZE), 0); ExpectIntEQ(XMEMCMP(privKey, dk_768, WC_ML_KEM_768_PRIVATE_KEY_SIZE), 0);
wc_KyberKey_Free(key); wc_MlKem_Free(key);
#endif #endif
#ifndef WOLFSSL_NO_ML_KEM_1024 #ifndef WOLFSSL_NO_ML_KEM_1024
ExpectIntEQ(wc_KyberKey_Init(WC_ML_KEM_1024, key, NULL, INVALID_DEVID), 0); ExpectIntEQ(wc_MlKem_Init(WC_ML_KEM_1024, key, NULL, INVALID_DEVID), 0);
ExpectIntEQ(wc_KyberKey_MakeKeyWithRandom(key, seed_1024, ExpectIntEQ(wc_MlKem_MakeKeyWithRandom(key, seed_1024,
sizeof(seed_1024)), 0); sizeof(seed_1024)), 0);
ExpectIntEQ(wc_KyberKey_EncodePublicKey(key, pubKey, ExpectIntEQ(wc_MlKem_EncodePublicKey(key, pubKey,
WC_ML_KEM_1024_PUBLIC_KEY_SIZE), 0); WC_ML_KEM_1024_PUBLIC_KEY_SIZE), 0);
ExpectIntEQ(wc_KyberKey_EncodePrivateKey(key, privKey, ExpectIntEQ(wc_MlKem_EncodePrivateKey(key, privKey,
WC_ML_KEM_1024_PRIVATE_KEY_SIZE), 0); WC_ML_KEM_1024_PRIVATE_KEY_SIZE), 0);
ExpectIntEQ(XMEMCMP(pubKey, ek_1024, WC_ML_KEM_1024_PUBLIC_KEY_SIZE), 0); ExpectIntEQ(XMEMCMP(pubKey, ek_1024, WC_ML_KEM_1024_PUBLIC_KEY_SIZE), 0);
ExpectIntEQ(XMEMCMP(privKey, dk_1024, WC_ML_KEM_1024_PRIVATE_KEY_SIZE), 0); ExpectIntEQ(XMEMCMP(privKey, dk_1024, WC_ML_KEM_1024_PRIVATE_KEY_SIZE), 0);
wc_KyberKey_Free(key); wc_MlKem_Free(key);
#endif #endif
XFREE(key, NULL, DYNAMIC_TYPE_TMP_BUFFER); XFREE(key, NULL, DYNAMIC_TYPE_TMP_BUFFER);
@ -27979,31 +27979,31 @@ static int test_wc_kyber_encapsulate_kats(void)
} }
#ifndef WOLFSSL_NO_ML_KEM_512 #ifndef WOLFSSL_NO_ML_KEM_512
ExpectIntEQ(wc_KyberKey_Init(WC_ML_KEM_512, key, NULL, INVALID_DEVID), 0); ExpectIntEQ(wc_MlKem_Init(WC_ML_KEM_512, key, NULL, INVALID_DEVID), 0);
ExpectIntEQ(wc_KyberKey_DecodePublicKey(key, ek_512, sizeof(ek_512)), 0); ExpectIntEQ(wc_MlKem_DecodePublicKey(key, ek_512, sizeof(ek_512)), 0);
ExpectIntEQ(wc_KyberKey_EncapsulateWithRandom(key, ct, ss, seed_512, ExpectIntEQ(wc_MlKem_EncapsulateWithRandom(key, ct, ss, seed_512,
sizeof(seed_512)), 0); sizeof(seed_512)), 0);
ExpectIntEQ(XMEMCMP(ct, c_512, WC_ML_KEM_512_CIPHER_TEXT_SIZE), 0); ExpectIntEQ(XMEMCMP(ct, c_512, WC_ML_KEM_512_CIPHER_TEXT_SIZE), 0);
ExpectIntEQ(XMEMCMP(ss, k_512, WC_ML_KEM_SS_SZ), 0); ExpectIntEQ(XMEMCMP(ss, k_512, WC_ML_KEM_SS_SZ), 0);
wc_KyberKey_Free(key); wc_MlKem_Free(key);
#endif #endif
#ifndef WOLFSSL_NO_ML_KEM_768 #ifndef WOLFSSL_NO_ML_KEM_768
ExpectIntEQ(wc_KyberKey_Init(WC_ML_KEM_768, key, NULL, INVALID_DEVID), 0); ExpectIntEQ(wc_MlKem_Init(WC_ML_KEM_768, key, NULL, INVALID_DEVID), 0);
ExpectIntEQ(wc_KyberKey_DecodePublicKey(key, ek_768, sizeof(ek_768)), 0); ExpectIntEQ(wc_MlKem_DecodePublicKey(key, ek_768, sizeof(ek_768)), 0);
ExpectIntEQ(wc_KyberKey_EncapsulateWithRandom(key, ct, ss, seed_768, ExpectIntEQ(wc_MlKem_EncapsulateWithRandom(key, ct, ss, seed_768,
sizeof(seed_768)), 0); sizeof(seed_768)), 0);
ExpectIntEQ(XMEMCMP(ct, c_768, WC_ML_KEM_768_CIPHER_TEXT_SIZE), 0); ExpectIntEQ(XMEMCMP(ct, c_768, WC_ML_KEM_768_CIPHER_TEXT_SIZE), 0);
ExpectIntEQ(XMEMCMP(ss, k_768, WC_ML_KEM_SS_SZ), 0); ExpectIntEQ(XMEMCMP(ss, k_768, WC_ML_KEM_SS_SZ), 0);
wc_KyberKey_Free(key); wc_MlKem_Free(key);
#endif #endif
#ifndef WOLFSSL_NO_ML_KEM_1024 #ifndef WOLFSSL_NO_ML_KEM_1024
ExpectIntEQ(wc_KyberKey_Init(WC_ML_KEM_1024, key, NULL, INVALID_DEVID), 0); ExpectIntEQ(wc_MlKem_Init(WC_ML_KEM_1024, key, NULL, INVALID_DEVID), 0);
ExpectIntEQ(wc_KyberKey_DecodePublicKey(key, ek_1024, sizeof(ek_1024)), 0); ExpectIntEQ(wc_MlKem_DecodePublicKey(key, ek_1024, sizeof(ek_1024)), 0);
ExpectIntEQ(wc_KyberKey_EncapsulateWithRandom(key, ct, ss, seed_1024, ExpectIntEQ(wc_MlKem_EncapsulateWithRandom(key, ct, ss, seed_1024,
sizeof(seed_1024)), 0); sizeof(seed_1024)), 0);
ExpectIntEQ(XMEMCMP(ct, c_1024, WC_ML_KEM_1024_CIPHER_TEXT_SIZE), 0); ExpectIntEQ(XMEMCMP(ct, c_1024, WC_ML_KEM_1024_CIPHER_TEXT_SIZE), 0);
ExpectIntEQ(XMEMCMP(ss, k_1024, WC_ML_KEM_SS_SZ), 0); ExpectIntEQ(XMEMCMP(ss, k_1024, WC_ML_KEM_SS_SZ), 0);
wc_KyberKey_Free(key); wc_MlKem_Free(key);
#endif #endif
XFREE(key, NULL, DYNAMIC_TYPE_TMP_BUFFER); XFREE(key, NULL, DYNAMIC_TYPE_TMP_BUFFER);
@ -29390,25 +29390,25 @@ static int test_wc_kyber_decapsulate_kats(void)
} }
#ifndef WOLFSSL_NO_ML_KEM_512 #ifndef WOLFSSL_NO_ML_KEM_512
ExpectIntEQ(wc_KyberKey_Init(WC_ML_KEM_512, key, NULL, INVALID_DEVID), 0); ExpectIntEQ(wc_MlKem_Init(WC_ML_KEM_512, key, NULL, INVALID_DEVID), 0);
ExpectIntEQ(wc_KyberKey_DecodePrivateKey(key, dk_512, sizeof(dk_512)), 0); ExpectIntEQ(wc_MlKem_DecodePrivateKey(key, dk_512, sizeof(dk_512)), 0);
ExpectIntEQ(wc_KyberKey_Decapsulate(key, ss, c_512, sizeof(c_512)), 0); ExpectIntEQ(wc_MlKem_Decapsulate(key, ss, c_512, sizeof(c_512)), 0);
ExpectIntEQ(XMEMCMP(ss, kprime_512, WC_ML_KEM_SS_SZ), 0); ExpectIntEQ(XMEMCMP(ss, kprime_512, WC_ML_KEM_SS_SZ), 0);
wc_KyberKey_Free(key); wc_MlKem_Free(key);
#endif #endif
#ifndef WOLFSSL_NO_ML_KEM_768 #ifndef WOLFSSL_NO_ML_KEM_768
ExpectIntEQ(wc_KyberKey_Init(WC_ML_KEM_768, key, NULL, INVALID_DEVID), 0); ExpectIntEQ(wc_MlKem_Init(WC_ML_KEM_768, key, NULL, INVALID_DEVID), 0);
ExpectIntEQ(wc_KyberKey_DecodePrivateKey(key, dk_768, sizeof(dk_768)), 0); ExpectIntEQ(wc_MlKem_DecodePrivateKey(key, dk_768, sizeof(dk_768)), 0);
ExpectIntEQ(wc_KyberKey_Decapsulate(key, ss, c_768, sizeof(c_768)), 0); ExpectIntEQ(wc_MlKem_Decapsulate(key, ss, c_768, sizeof(c_768)), 0);
ExpectIntEQ(XMEMCMP(ss, kprime_768, WC_ML_KEM_SS_SZ), 0); ExpectIntEQ(XMEMCMP(ss, kprime_768, WC_ML_KEM_SS_SZ), 0);
wc_KyberKey_Free(key); wc_MlKem_Free(key);
#endif #endif
#ifndef WOLFSSL_NO_ML_KEM_1024 #ifndef WOLFSSL_NO_ML_KEM_1024
ExpectIntEQ(wc_KyberKey_Init(WC_ML_KEM_1024, key, NULL, INVALID_DEVID), 0); ExpectIntEQ(wc_MlKem_Init(WC_ML_KEM_1024, key, NULL, INVALID_DEVID), 0);
ExpectIntEQ(wc_KyberKey_DecodePrivateKey(key, dk_1024, sizeof(dk_1024)), 0); ExpectIntEQ(wc_MlKem_DecodePrivateKey(key, dk_1024, sizeof(dk_1024)), 0);
ExpectIntEQ(wc_KyberKey_Decapsulate(key, ss, c_1024, sizeof(c_1024)), 0); ExpectIntEQ(wc_MlKem_Decapsulate(key, ss, c_1024, sizeof(c_1024)), 0);
ExpectIntEQ(XMEMCMP(ss, kprime_1024, WC_ML_KEM_SS_SZ), 0); ExpectIntEQ(XMEMCMP(ss, kprime_1024, WC_ML_KEM_SS_SZ), 0);
wc_KyberKey_Free(key); wc_MlKem_Free(key);
#endif #endif
XFREE(key, NULL, DYNAMIC_TYPE_TMP_BUFFER); XFREE(key, NULL, DYNAMIC_TYPE_TMP_BUFFER);

28
wolfcrypt/benchmark/benchmark.c
View File

@ -9666,16 +9666,16 @@ static void bench_kyber_keygen(int type, const char* name, int keySize,
do { do {
/* while free pending slots in queue, submit ops */ /* while free pending slots in queue, submit ops */
for (times = 0; times < agreeTimes || pending > 0; times++) { for (times = 0; times < agreeTimes || pending > 0; times++) {
wc_KyberKey_Free(key); wc_MlKem_Free(key);
ret = wc_KyberKey_Init(type, key, HEAP_HINT, INVALID_DEVID); ret = wc_MlKem_Init(type, key, HEAP_HINT, INVALID_DEVID);
if (ret != 0) if (ret != 0)
goto exit; goto exit;
#ifdef KYBER_NONDETERMINISTIC #ifdef KYBER_NONDETERMINISTIC
ret = wc_KyberKey_MakeKey(key, &gRng); ret = wc_MlKem_MakeKey(key, &gRng);
#else #else
unsigned char rand[KYBER_MAKEKEY_RAND_SZ] = {0,}; unsigned char rand[KYBER_MAKEKEY_RAND_SZ] = {0,};
ret = wc_KyberKey_MakeKeyWithRandom(key, rand, sizeof(rand)); ret = wc_MlKem_MakeKeyWithRandom(key, rand, sizeof(rand));
#endif #endif
if (ret != 0) if (ret != 0)
goto exit; goto exit;
@ -9708,24 +9708,24 @@ static void bench_kyber_encap(int type, const char* name, int keySize,
word32 ctSz; word32 ctSz;
DECLARE_MULTI_VALUE_STATS_VARS() DECLARE_MULTI_VALUE_STATS_VARS()
ret = wc_KyberKey_PublicKeySize(key1, &pubLen); ret = wc_MlKem_PublicKeySize(key1, &pubLen);
if (ret != 0) { if (ret != 0) {
return; return;
} }
ret = wc_KyberKey_EncodePublicKey(key1, pub, pubLen); ret = wc_MlKem_EncodePublicKey(key1, pub, pubLen);
if (ret != 0) { if (ret != 0) {
return; return;
} }
ret = wc_KyberKey_Init(type, key2, HEAP_HINT, INVALID_DEVID); ret = wc_MlKem_Init(type, key2, HEAP_HINT, INVALID_DEVID);
if (ret != 0) { if (ret != 0) {
return; return;
} }
ret = wc_KyberKey_DecodePublicKey(key2, pub, pubLen); ret = wc_MlKem_DecodePublicKey(key2, pub, pubLen);
if (ret != 0) { if (ret != 0) {
return; return;
} }
ret = wc_KyberKey_CipherTextSize(key2, &ctSz); ret = wc_MlKem_CipherTextSize(key2, &ctSz);
if (ret != 0) { if (ret != 0) {
return; return;
} }
@ -9736,10 +9736,10 @@ static void bench_kyber_encap(int type, const char* name, int keySize,
/* while free pending slots in queue, submit ops */ /* while free pending slots in queue, submit ops */
for (times = 0; times < agreeTimes || pending > 0; times++) { for (times = 0; times < agreeTimes || pending > 0; times++) {
#ifdef KYBER_NONDETERMINISTIC #ifdef KYBER_NONDETERMINISTIC
ret = wc_KyberKey_Encapsulate(key2, ct, ss, &gRng); ret = wc_MlKem_Encapsulate(key2, ct, ss, &gRng);
#else #else
unsigned char rand[KYBER_ENC_RAND_SZ] = {0,}; unsigned char rand[KYBER_ENC_RAND_SZ] = {0,};
ret = wc_KyberKey_EncapsulateWithRandom(key2, ct, ss, rand, ret = wc_MlKem_EncapsulateWithRandom(key2, ct, ss, rand,
sizeof(rand)); sizeof(rand));
#endif #endif
if (ret != 0) if (ret != 0)
@ -9766,7 +9766,7 @@ exit_encap:
do { do {
/* while free pending slots in queue, submit ops */ /* while free pending slots in queue, submit ops */
for (times = 0; times < agreeTimes || pending > 0; times++) { for (times = 0; times < agreeTimes || pending > 0; times++) {
ret = wc_KyberKey_Decapsulate(key1, ss, ct, ctSz); ret = wc_MlKem_Decapsulate(key1, ss, ct, ctSz);
if (ret != 0) if (ret != 0)
goto exit_decap; goto exit_decap;
RECORD_MULTI_VALUE_STATS(); RECORD_MULTI_VALUE_STATS();
@ -9838,8 +9838,8 @@ void bench_kyber(int type)
bench_kyber_keygen(type, name, keySize, &key1); bench_kyber_keygen(type, name, keySize, &key1);
bench_kyber_encap(type, name, keySize, &key1, &key2); bench_kyber_encap(type, name, keySize, &key1, &key2);
wc_KyberKey_Free(&key2); wc_MlKem_Free(&key2);
wc_KyberKey_Free(&key1); wc_MlKem_Free(&key1);
} }
#endif #endif

46
wolfcrypt/src/ext_kyber.c
View File

@ -79,7 +79,7 @@ int ext_kyber_enabled(int id)
* @return BAD_FUNC_ARG when key is NULL or type is unrecognized. * @return BAD_FUNC_ARG when key is NULL or type is unrecognized.
* @return NOT_COMPILED_IN when key type is not supported. * @return NOT_COMPILED_IN when key type is not supported.
*/ */
int wc_KyberKey_Init(int type, KyberKey* key, void* heap, int devId) int wc_MlKem_Init(int type, KyberKey* key, void* heap, int devId)
{ {
int ret = 0; int ret = 0;
@ -135,7 +135,7 @@ int wc_KyberKey_Init(int type, KyberKey* key, void* heap, int devId)
* *
* @param [in, out] key Kyber key object to dispose of. * @param [in, out] key Kyber key object to dispose of.
*/ */
void wc_KyberKey_Free(KyberKey* key) void wc_MlKem_Free(KyberKey* key)
{ {
if (key != NULL) { if (key != NULL) {
/* Ensure all private data is zeroed. */ /* Ensure all private data is zeroed. */
@ -155,7 +155,7 @@ void wc_KyberKey_Free(KyberKey* key)
* @return BAD_FUNC_ARG when key or len is NULL. * @return BAD_FUNC_ARG when key or len is NULL.
* @return NOT_COMPILED_IN when key type is not supported. * @return NOT_COMPILED_IN when key type is not supported.
*/ */
int wc_KyberKey_PrivateKeySize(KyberKey* key, word32* len) int wc_MlKem_PrivateKeySize(KyberKey* key, word32* len)
{ {
int ret = 0; int ret = 0;
@ -210,7 +210,7 @@ int wc_KyberKey_PrivateKeySize(KyberKey* key, word32* len)
* @return BAD_FUNC_ARG when key or len is NULL. * @return BAD_FUNC_ARG when key or len is NULL.
* @return NOT_COMPILED_IN when key type is not supported. * @return NOT_COMPILED_IN when key type is not supported.
*/ */
int wc_KyberKey_PublicKeySize(KyberKey* key, word32* len) int wc_MlKem_PublicKeySize(KyberKey* key, word32* len)
{ {
int ret = 0; int ret = 0;
@ -265,7 +265,7 @@ int wc_KyberKey_PublicKeySize(KyberKey* key, word32* len)
* @return BAD_FUNC_ARG when key or len is NULL. * @return BAD_FUNC_ARG when key or len is NULL.
* @return NOT_COMPILED_IN when key type is not supported. * @return NOT_COMPILED_IN when key type is not supported.
*/ */
int wc_KyberKey_CipherTextSize(KyberKey* key, word32* len) int wc_MlKem_CipherTextSize(KyberKey* key, word32* len)
{ {
int ret = 0; int ret = 0;
@ -319,7 +319,7 @@ int wc_KyberKey_CipherTextSize(KyberKey* key, word32* len)
* @return 0 on success. * @return 0 on success.
* @return 0 to indicate success. * @return 0 to indicate success.
*/ */
int wc_KyberKey_SharedSecretSize(KyberKey* key, word32* len) int wc_MlKem_SharedSecretSize(KyberKey* key, word32* len)
{ {
(void)key; (void)key;
/* Validate parameters. */ /* Validate parameters. */
@ -346,7 +346,7 @@ int wc_KyberKey_SharedSecretSize(KyberKey* key, word32* len)
* @return BAD_FUNC_ARG when key or rng is NULL. * @return BAD_FUNC_ARG when key or rng is NULL.
* @return MEMORY_E when dynamic memory allocation failed. * @return MEMORY_E when dynamic memory allocation failed.
*/ */
int wc_KyberKey_MakeKey(KyberKey* key, WC_RNG* rng) int wc_MlKem_MakeKey(KyberKey* key, WC_RNG* rng)
{ {
int ret = 0; int ret = 0;
#ifdef HAVE_LIBOQS #ifdef HAVE_LIBOQS
@ -418,13 +418,13 @@ int wc_KyberKey_MakeKey(KyberKey* key, WC_RNG* rng)
* @return NOT_COMPILED_IN when key type is not supported. * @return NOT_COMPILED_IN when key type is not supported.
* @return MEMORY_E when dynamic memory allocation failed. * @return MEMORY_E when dynamic memory allocation failed.
*/ */
int wc_KyberKey_MakeKeyWithRandom(KyberKey* key, const unsigned char* rand, int wc_MlKem_MakeKeyWithRandom(KyberKey* key, const unsigned char* rand,
int len) int len)
{ {
(void)rand; (void)rand;
(void)len; (void)len;
/* OQS doesn't support external randomness. */ /* OQS doesn't support external randomness. */
return wc_KyberKey_MakeKey(key, NULL); return wc_MlKem_MakeKey(key, NULL);
} }
/** /**
@ -439,7 +439,7 @@ int wc_KyberKey_MakeKeyWithRandom(KyberKey* key, const unsigned char* rand,
* @return NOT_COMPILED_IN when key type is not supported. * @return NOT_COMPILED_IN when key type is not supported.
* @return MEMORY_E when dynamic memory allocation failed. * @return MEMORY_E when dynamic memory allocation failed.
*/ */
int wc_KyberKey_Encapsulate(KyberKey* key, unsigned char* ct, unsigned char* ss, int wc_MlKem_Encapsulate(KyberKey* key, unsigned char* ct, unsigned char* ss,
WC_RNG* rng) WC_RNG* rng)
{ {
int ret = 0; int ret = 0;
@ -460,7 +460,7 @@ int wc_KyberKey_Encapsulate(KyberKey* key, unsigned char* ct, unsigned char* ss,
#ifdef WOLF_CRYPTO_CB #ifdef WOLF_CRYPTO_CB
if (ret == 0) { if (ret == 0) {
ret = wc_KyberKey_CipherTextSize(key, &ctlen); ret = wc_MlKem_CipherTextSize(key, &ctlen);
} }
if ((ret == 0) if ((ret == 0)
#ifndef WOLF_CRYPTO_CB_FIND #ifndef WOLF_CRYPTO_CB_FIND
@ -517,13 +517,13 @@ int wc_KyberKey_Encapsulate(KyberKey* key, unsigned char* ct, unsigned char* ss,
* @return NOT_COMPILED_IN when key type is not supported. * @return NOT_COMPILED_IN when key type is not supported.
* @return MEMORY_E when dynamic memory allocation failed. * @return MEMORY_E when dynamic memory allocation failed.
*/ */
int wc_KyberKey_EncapsulateWithRandom(KyberKey* key, unsigned char* ct, int wc_MlKem_EncapsulateWithRandom(KyberKey* key, unsigned char* ct,
unsigned char* ss, const unsigned char* rand, int len) unsigned char* ss, const unsigned char* rand, int len)
{ {
(void)rand; (void)rand;
(void)len; (void)len;
/* OQS doesn't support external randomness. */ /* OQS doesn't support external randomness. */
return wc_KyberKey_Encapsulate(key, ct, ss, NULL); return wc_MlKem_Encapsulate(key, ct, ss, NULL);
} }
/** /**
@ -541,7 +541,7 @@ int wc_KyberKey_EncapsulateWithRandom(KyberKey* key, unsigned char* ct,
* @return BUFFER_E when len is not the length of cipher text for the key type. * @return BUFFER_E when len is not the length of cipher text for the key type.
* @return MEMORY_E when dynamic memory allocation failed. * @return MEMORY_E when dynamic memory allocation failed.
*/ */
int wc_KyberKey_Decapsulate(KyberKey* key, unsigned char* ss, int wc_MlKem_Decapsulate(KyberKey* key, unsigned char* ss,
const unsigned char* ct, word32 len) const unsigned char* ct, word32 len)
{ {
int ret = 0; int ret = 0;
@ -556,7 +556,7 @@ int wc_KyberKey_Decapsulate(KyberKey* key, unsigned char* ss,
ret = BAD_FUNC_ARG; ret = BAD_FUNC_ARG;
} }
if (ret == 0) { if (ret == 0) {
ret = wc_KyberKey_CipherTextSize(key, &ctlen); ret = wc_MlKem_CipherTextSize(key, &ctlen);
} }
if ((ret == 0) && (len != ctlen)) { if ((ret == 0) && (len != ctlen)) {
ret = BUFFER_E; ret = BUFFER_E;
@ -621,7 +621,7 @@ int wc_KyberKey_Decapsulate(KyberKey* key, unsigned char* ss,
* @return NOT_COMPILED_IN when key type is not supported. * @return NOT_COMPILED_IN when key type is not supported.
* @return BUFFER_E when len is not the correct size. * @return BUFFER_E when len is not the correct size.
*/ */
int wc_KyberKey_DecodePrivateKey(KyberKey* key, const unsigned char* in, int wc_MlKem_DecodePrivateKey(KyberKey* key, const unsigned char* in,
word32 len) word32 len)
{ {
int ret = 0; int ret = 0;
@ -633,7 +633,7 @@ int wc_KyberKey_DecodePrivateKey(KyberKey* key, const unsigned char* in,
} }
if (ret == 0) { if (ret == 0) {
ret = wc_KyberKey_PrivateKeySize(key, &privLen); ret = wc_MlKem_PrivateKeySize(key, &privLen);
} }
/* Ensure the data is the correct length for the key type. */ /* Ensure the data is the correct length for the key type. */
@ -661,7 +661,7 @@ int wc_KyberKey_DecodePrivateKey(KyberKey* key, const unsigned char* in,
* @return NOT_COMPILED_IN when key type is not supported. * @return NOT_COMPILED_IN when key type is not supported.
* @return BUFFER_E when len is not the correct size. * @return BUFFER_E when len is not the correct size.
*/ */
int wc_KyberKey_DecodePublicKey(KyberKey* key, const unsigned char* in, int wc_MlKem_DecodePublicKey(KyberKey* key, const unsigned char* in,
word32 len) word32 len)
{ {
int ret = 0; int ret = 0;
@ -673,7 +673,7 @@ int wc_KyberKey_DecodePublicKey(KyberKey* key, const unsigned char* in,
} }
if (ret == 0) { if (ret == 0) {
ret = wc_KyberKey_PublicKeySize(key, &pubLen); ret = wc_MlKem_PublicKeySize(key, &pubLen);
} }
/* Ensure the data is the correct length for the key type. */ /* Ensure the data is the correct length for the key type. */
@ -701,7 +701,7 @@ int wc_KyberKey_DecodePublicKey(KyberKey* key, const unsigned char* in,
* available. * available.
* @return NOT_COMPILED_IN when key type is not supported. * @return NOT_COMPILED_IN when key type is not supported.
*/ */
int wc_KyberKey_EncodePrivateKey(KyberKey* key, unsigned char* out, word32 len) int wc_MlKem_EncodePrivateKey(KyberKey* key, unsigned char* out, word32 len)
{ {
int ret = 0; int ret = 0;
unsigned int privLen = 0; unsigned int privLen = 0;
@ -711,7 +711,7 @@ int wc_KyberKey_EncodePrivateKey(KyberKey* key, unsigned char* out, word32 len)
} }
if (ret == 0) { if (ret == 0) {
ret = wc_KyberKey_PrivateKeySize(key, &privLen); ret = wc_MlKem_PrivateKeySize(key, &privLen);
} }
/* Check buffer is big enough for encoding. */ /* Check buffer is big enough for encoding. */
@ -738,7 +738,7 @@ int wc_KyberKey_EncodePrivateKey(KyberKey* key, unsigned char* out, word32 len)
* @return BAD_FUNC_ARG when key or out is NULL or public key not available. * @return BAD_FUNC_ARG when key or out is NULL or public key not available.
* @return NOT_COMPILED_IN when key type is not supported. * @return NOT_COMPILED_IN when key type is not supported.
*/ */
int wc_KyberKey_EncodePublicKey(KyberKey* key, unsigned char* out, word32 len) int wc_MlKem_EncodePublicKey(KyberKey* key, unsigned char* out, word32 len)
{ {
int ret = 0; int ret = 0;
unsigned int pubLen = 0; unsigned int pubLen = 0;
@ -748,7 +748,7 @@ int wc_KyberKey_EncodePublicKey(KyberKey* key, unsigned char* out, word32 len)
} }
if (ret == 0) { if (ret == 0) {
ret = wc_KyberKey_PublicKeySize(key, &pubLen); ret = wc_MlKem_PublicKeySize(key, &pubLen);
} }
/* Check buffer is big enough for encoding. */ /* Check buffer is big enough for encoding. */

42
wolfcrypt/src/wc_kyber.c
View File

@ -106,7 +106,7 @@ volatile sword16 kyber_opt_blocker = 0;
* @return BAD_FUNC_ARG when key is NULL or type is unrecognized. * @return BAD_FUNC_ARG when key is NULL or type is unrecognized.
* @return NOT_COMPILED_IN when key type is not supported. * @return NOT_COMPILED_IN when key type is not supported.
*/ */
int wc_KyberKey_Init(int type, KyberKey* key, void* heap, int devId) int wc_MlKem_Init(int type, KyberKey* key, void* heap, int devId)
{ {
int ret = 0; int ret = 0;
@ -197,7 +197,7 @@ int wc_KyberKey_Init(int type, KyberKey* key, void* heap, int devId)
* *
* @param [in, out] key Kyber key object to dispose of. * @param [in, out] key Kyber key object to dispose of.
*/ */
void wc_KyberKey_Free(KyberKey* key) void wc_MlKem_Free(KyberKey* key)
{ {
if (key != NULL) { if (key != NULL) {
/* Dispose of PRF object. */ /* Dispose of PRF object. */
@ -220,7 +220,7 @@ void wc_KyberKey_Free(KyberKey* key)
* @return BAD_FUNC_ARG when key or rng is NULL. * @return BAD_FUNC_ARG when key or rng is NULL.
* @return MEMORY_E when dynamic memory allocation failed. * @return MEMORY_E when dynamic memory allocation failed.
*/ */
int wc_KyberKey_MakeKey(KyberKey* key, WC_RNG* rng) int wc_MlKem_MakeKey(KyberKey* key, WC_RNG* rng)
{ {
int ret = 0; int ret = 0;
unsigned char rand[KYBER_MAKEKEY_RAND_SZ]; unsigned char rand[KYBER_MAKEKEY_RAND_SZ];
@ -240,7 +240,7 @@ int wc_KyberKey_MakeKey(KyberKey* key, WC_RNG* rng)
} }
if (ret == 0) { if (ret == 0) {
/* Make a key pair from the random. */ /* Make a key pair from the random. */
ret = wc_KyberKey_MakeKeyWithRandom(key, rand, sizeof(rand)); ret = wc_MlKem_MakeKeyWithRandom(key, rand, sizeof(rand));
} }
/* Ensure seeds are zeroized. */ /* Ensure seeds are zeroized. */
@ -261,7 +261,7 @@ int wc_KyberKey_MakeKey(KyberKey* key, WC_RNG* rng)
* @return NOT_COMPILED_IN when key type is not supported. * @return NOT_COMPILED_IN when key type is not supported.
* @return MEMORY_E when dynamic memory allocation failed. * @return MEMORY_E when dynamic memory allocation failed.
*/ */
int wc_KyberKey_MakeKeyWithRandom(KyberKey* key, const unsigned char* rand, int wc_MlKem_MakeKeyWithRandom(KyberKey* key, const unsigned char* rand,
int len) int len)
{ {
byte buf[2 * KYBER_SYM_SZ + 1]; byte buf[2 * KYBER_SYM_SZ + 1];
@ -453,7 +453,7 @@ int wc_KyberKey_MakeKeyWithRandom(KyberKey* key, const unsigned char* rand,
* @return BAD_FUNC_ARG when key or len is NULL. * @return BAD_FUNC_ARG when key or len is NULL.
* @return NOT_COMPILED_IN when key type is not supported. * @return NOT_COMPILED_IN when key type is not supported.
*/ */
int wc_KyberKey_CipherTextSize(KyberKey* key, word32* len) int wc_MlKem_CipherTextSize(KyberKey* key, word32* len)
{ {
int ret = 0; int ret = 0;
@ -517,7 +517,7 @@ int wc_KyberKey_CipherTextSize(KyberKey* key, word32* len)
* @return 0 on success. * @return 0 on success.
* @return 0 to indicate success. * @return 0 to indicate success.
*/ */
int wc_KyberKey_SharedSecretSize(KyberKey* key, word32* len) int wc_MlKem_SharedSecretSize(KyberKey* key, word32* len)
{ {
(void)key; (void)key;
@ -734,7 +734,7 @@ static int kyberkey_encapsulate(KyberKey* key, const byte* msg, byte* coins,
* @return NOT_COMPILED_IN when key type is not supported. * @return NOT_COMPILED_IN when key type is not supported.
* @return MEMORY_E when dynamic memory allocation failed. * @return MEMORY_E when dynamic memory allocation failed.
*/ */
int wc_KyberKey_Encapsulate(KyberKey* key, unsigned char* ct, unsigned char* ss, int wc_MlKem_Encapsulate(KyberKey* key, unsigned char* ct, unsigned char* ss,
WC_RNG* rng) WC_RNG* rng)
{ {
int ret = 0; int ret = 0;
@ -751,7 +751,7 @@ int wc_KyberKey_Encapsulate(KyberKey* key, unsigned char* ct, unsigned char* ss,
} }
if (ret == 0) { if (ret == 0) {
/* Encapsulate with the random. */ /* Encapsulate with the random. */
ret = wc_KyberKey_EncapsulateWithRandom(key, ct, ss, rand, ret = wc_MlKem_EncapsulateWithRandom(key, ct, ss, rand,
sizeof(rand)); sizeof(rand));
} }
@ -771,7 +771,7 @@ int wc_KyberKey_Encapsulate(KyberKey* key, unsigned char* ct, unsigned char* ss,
* @return NOT_COMPILED_IN when key type is not supported. * @return NOT_COMPILED_IN when key type is not supported.
* @return MEMORY_E when dynamic memory allocation failed. * @return MEMORY_E when dynamic memory allocation failed.
*/ */
int wc_KyberKey_EncapsulateWithRandom(KyberKey* key, unsigned char* ct, int wc_MlKem_EncapsulateWithRandom(KyberKey* key, unsigned char* ct,
unsigned char* ss, const unsigned char* rand, int len) unsigned char* ss, const unsigned char* rand, int len)
{ {
#ifdef WOLFSSL_KYBER_ORIGINAL #ifdef WOLFSSL_KYBER_ORIGINAL
@ -842,7 +842,7 @@ int wc_KyberKey_EncapsulateWithRandom(KyberKey* key, unsigned char* ct,
#ifndef WOLFSSL_NO_MALLOC #ifndef WOLFSSL_NO_MALLOC
/* Determine how big an encoded public key will be. */ /* Determine how big an encoded public key will be. */
ret = wc_KyberKey_PublicKeySize(key, &pubKeyLen); ret = wc_MlKem_PublicKeySize(key, &pubKeyLen);
if (ret == 0) { if (ret == 0) {
/* Allocate dynamic memory for encoded public key. */ /* Allocate dynamic memory for encoded public key. */
pubKey = (byte*)XMALLOC(pubKeyLen, key->heap, pubKey = (byte*)XMALLOC(pubKeyLen, key->heap,
@ -854,7 +854,7 @@ int wc_KyberKey_EncapsulateWithRandom(KyberKey* key, unsigned char* ct,
if (ret == 0) { if (ret == 0) {
#endif #endif
/* Encode public key - h is hash of encoded public key. */ /* Encode public key - h is hash of encoded public key. */
ret = wc_KyberKey_EncodePublicKey(key, pubKey, pubKeyLen); ret = wc_MlKem_EncodePublicKey(key, pubKey, pubKeyLen);
#ifndef WOLFSSL_NO_MALLOC #ifndef WOLFSSL_NO_MALLOC
} }
/* Dispose of encoded public key. */ /* Dispose of encoded public key. */
@ -1119,7 +1119,7 @@ static int kyber_derive_secret(const byte* z, const byte* ct, word32 ctSz,
* @return BUFFER_E when len is not the length of cipher text for the key type. * @return BUFFER_E when len is not the length of cipher text for the key type.
* @return MEMORY_E when dynamic memory allocation failed. * @return MEMORY_E when dynamic memory allocation failed.
*/ */
int wc_KyberKey_Decapsulate(KyberKey* key, unsigned char* ss, int wc_MlKem_Decapsulate(KyberKey* key, unsigned char* ss,
const unsigned char* ct, word32 len) const unsigned char* ct, word32 len)
{ {
byte msg[KYBER_SYM_SZ]; byte msg[KYBER_SYM_SZ];
@ -1274,7 +1274,7 @@ int wc_KyberKey_Decapsulate(KyberKey* key, unsigned char* ss,
* @return NOT_COMPILED_IN when key type is not supported. * @return NOT_COMPILED_IN when key type is not supported.
* @return BUFFER_E when len is not the correct size. * @return BUFFER_E when len is not the correct size.
*/ */
int wc_KyberKey_DecodePrivateKey(KyberKey* key, const unsigned char* in, int wc_MlKem_DecodePrivateKey(KyberKey* key, const unsigned char* in,
word32 len) word32 len)
{ {
int ret = 0; int ret = 0;
@ -1354,7 +1354,7 @@ int wc_KyberKey_DecodePrivateKey(KyberKey* key, const unsigned char* in,
p += k * KYBER_POLY_SIZE; p += k * KYBER_POLY_SIZE;
/* Decode the public key that is after the private key. */ /* Decode the public key that is after the private key. */
ret = wc_KyberKey_DecodePublicKey(key, p, pubLen); ret = wc_MlKem_DecodePublicKey(key, p, pubLen);
} }
if (ret == 0) { if (ret == 0) {
/* Skip over public key. */ /* Skip over public key. */
@ -1384,7 +1384,7 @@ int wc_KyberKey_DecodePrivateKey(KyberKey* key, const unsigned char* in,
* @return NOT_COMPILED_IN when key type is not supported. * @return NOT_COMPILED_IN when key type is not supported.
* @return BUFFER_E when len is not the correct size. * @return BUFFER_E when len is not the correct size.
*/ */
int wc_KyberKey_DecodePublicKey(KyberKey* key, const unsigned char* in, int wc_MlKem_DecodePublicKey(KyberKey* key, const unsigned char* in,
word32 len) word32 len)
{ {
int ret = 0; int ret = 0;
@ -1481,7 +1481,7 @@ int wc_KyberKey_DecodePublicKey(KyberKey* key, const unsigned char* in,
* @return BAD_FUNC_ARG when key or len is NULL. * @return BAD_FUNC_ARG when key or len is NULL.
* @return NOT_COMPILED_IN when key type is not supported. * @return NOT_COMPILED_IN when key type is not supported.
*/ */
int wc_KyberKey_PrivateKeySize(KyberKey* key, word32* len) int wc_MlKem_PrivateKeySize(KyberKey* key, word32* len)
{ {
int ret = 0; int ret = 0;
@ -1547,7 +1547,7 @@ int wc_KyberKey_PrivateKeySize(KyberKey* key, word32* len)
* @return BAD_FUNC_ARG when key or len is NULL. * @return BAD_FUNC_ARG when key or len is NULL.
* @return NOT_COMPILED_IN when key type is not supported. * @return NOT_COMPILED_IN when key type is not supported.
*/ */
int wc_KyberKey_PublicKeySize(KyberKey* key, word32* len) int wc_MlKem_PublicKeySize(KyberKey* key, word32* len)
{ {
int ret = 0; int ret = 0;
@ -1617,7 +1617,7 @@ int wc_KyberKey_PublicKeySize(KyberKey* key, word32* len)
* available. * available.
* @return NOT_COMPILED_IN when key type is not supported. * @return NOT_COMPILED_IN when key type is not supported.
*/ */
int wc_KyberKey_EncodePrivateKey(KyberKey* key, unsigned char* out, word32 len) int wc_MlKem_EncodePrivateKey(KyberKey* key, unsigned char* out, word32 len)
{ {
int ret = 0; int ret = 0;
unsigned int k = 0; unsigned int k = 0;
@ -1698,7 +1698,7 @@ int wc_KyberKey_EncodePrivateKey(KyberKey* key, unsigned char* out, word32 len)
p += KYBER_POLY_SIZE * k; p += KYBER_POLY_SIZE * k;
/* Encode public key. */ /* Encode public key. */
ret = wc_KyberKey_EncodePublicKey(key, p, pubLen); ret = wc_MlKem_EncodePublicKey(key, p, pubLen);
p += pubLen; p += pubLen;
} }
/* Ensure hash of public key is available. */ /* Ensure hash of public key is available. */
@ -1730,7 +1730,7 @@ int wc_KyberKey_EncodePrivateKey(KyberKey* key, unsigned char* out, word32 len)
* @return BAD_FUNC_ARG when key or out is NULL or public key not available. * @return BAD_FUNC_ARG when key or out is NULL or public key not available.
* @return NOT_COMPILED_IN when key type is not supported. * @return NOT_COMPILED_IN when key type is not supported.
*/ */
int wc_KyberKey_EncodePublicKey(KyberKey* key, unsigned char* out, word32 len) int wc_MlKem_EncodePublicKey(KyberKey* key, unsigned char* out, word32 len)
{ {
int ret = 0; int ret = 0;
unsigned int k = 0; unsigned int k = 0;

104
wolfcrypt/test/test.c
View File

@ -39515,22 +39515,22 @@ static wc_test_ret_t kyber512_kat(void)
#endif #endif
#ifdef WOLFSSL_KYBER_ORIGINAL #ifdef WOLFSSL_KYBER_ORIGINAL
ret = wc_KyberKey_Init(KYBER512, key, HEAP_HINT, INVALID_DEVID); ret = wc_MlKem_Init(KYBER512, key, HEAP_HINT, INVALID_DEVID);
if (ret != 0) if (ret != 0)
ERROR_OUT(WC_TEST_RET_ENC_EC(ret), out); ERROR_OUT(WC_TEST_RET_ENC_EC(ret), out);
else else
key_inited = 1; key_inited = 1;
ret = wc_KyberKey_MakeKeyWithRandom(key, kyber512_rand, ret = wc_MlKem_MakeKeyWithRandom(key, kyber512_rand,
sizeof(kyber512_rand)); sizeof(kyber512_rand));
if (ret != 0) if (ret != 0)
ERROR_OUT(WC_TEST_RET_ENC_EC(ret), out); ERROR_OUT(WC_TEST_RET_ENC_EC(ret), out);
ret = wc_KyberKey_EncodePublicKey(key, pub, KYBER512_PUBLIC_KEY_SIZE); ret = wc_MlKem_EncodePublicKey(key, pub, KYBER512_PUBLIC_KEY_SIZE);
if (ret != 0) if (ret != 0)
ERROR_OUT(WC_TEST_RET_ENC_EC(ret), out); ERROR_OUT(WC_TEST_RET_ENC_EC(ret), out);
ret = wc_KyberKey_EncodePrivateKey(key, priv, KYBER512_PRIVATE_KEY_SIZE); ret = wc_MlKem_EncodePrivateKey(key, priv, KYBER512_PRIVATE_KEY_SIZE);
if (ret != 0) if (ret != 0)
ERROR_OUT(WC_TEST_RET_ENC_EC(ret), out); ERROR_OUT(WC_TEST_RET_ENC_EC(ret), out);
@ -39540,7 +39540,7 @@ static wc_test_ret_t kyber512_kat(void)
if (XMEMCMP(priv, kyber512_sk, sizeof(kyber512_sk)) != 0) if (XMEMCMP(priv, kyber512_sk, sizeof(kyber512_sk)) != 0)
ERROR_OUT(WC_TEST_RET_ENC_NC, out); ERROR_OUT(WC_TEST_RET_ENC_NC, out);
ret = wc_KyberKey_EncapsulateWithRandom(key, ct, ss, kyber512enc_rand, ret = wc_MlKem_EncapsulateWithRandom(key, ct, ss, kyber512enc_rand,
sizeof(kyber512enc_rand)); sizeof(kyber512enc_rand));
if (ret != 0) if (ret != 0)
ERROR_OUT(WC_TEST_RET_ENC_EC(ret), out); ERROR_OUT(WC_TEST_RET_ENC_EC(ret), out);
@ -39551,7 +39551,7 @@ static wc_test_ret_t kyber512_kat(void)
if (XMEMCMP(ss, kyber512_ss, sizeof(kyber512_ss)) != 0) if (XMEMCMP(ss, kyber512_ss, sizeof(kyber512_ss)) != 0)
ERROR_OUT(WC_TEST_RET_ENC_NC, out); ERROR_OUT(WC_TEST_RET_ENC_NC, out);
ret = wc_KyberKey_Decapsulate(key, ss_dec, ct, sizeof(kyber512_ct)); ret = wc_MlKem_Decapsulate(key, ss_dec, ct, sizeof(kyber512_ct));
if (ret != 0) if (ret != 0)
ERROR_OUT(WC_TEST_RET_ENC_EC(ret), out); ERROR_OUT(WC_TEST_RET_ENC_EC(ret), out);
@ -39559,22 +39559,22 @@ static wc_test_ret_t kyber512_kat(void)
ERROR_OUT(WC_TEST_RET_ENC_NC, out); ERROR_OUT(WC_TEST_RET_ENC_NC, out);
#endif #endif
#ifndef WOLFSSL_NO_ML_KEM #ifndef WOLFSSL_NO_ML_KEM
ret = wc_KyberKey_Init(WC_ML_KEM_512, key, HEAP_HINT, INVALID_DEVID); ret = wc_MlKem_Init(WC_ML_KEM_512, key, HEAP_HINT, INVALID_DEVID);
if (ret != 0) if (ret != 0)
ERROR_OUT(WC_TEST_RET_ENC_EC(ret), out); ERROR_OUT(WC_TEST_RET_ENC_EC(ret), out);
else else
key_inited = 1; key_inited = 1;
ret = wc_KyberKey_MakeKeyWithRandom(key, kyber512_rand, ret = wc_MlKem_MakeKeyWithRandom(key, kyber512_rand,
sizeof(kyber512_rand)); sizeof(kyber512_rand));
if (ret != 0) if (ret != 0)
ERROR_OUT(WC_TEST_RET_ENC_EC(ret), out); ERROR_OUT(WC_TEST_RET_ENC_EC(ret), out);
ret = wc_KyberKey_EncodePublicKey(key, pub, WC_ML_KEM_512_PUBLIC_KEY_SIZE); ret = wc_MlKem_EncodePublicKey(key, pub, WC_ML_KEM_512_PUBLIC_KEY_SIZE);
if (ret != 0) if (ret != 0)
ERROR_OUT(WC_TEST_RET_ENC_EC(ret), out); ERROR_OUT(WC_TEST_RET_ENC_EC(ret), out);
ret = wc_KyberKey_EncodePrivateKey(key, priv, ret = wc_MlKem_EncodePrivateKey(key, priv,
WC_ML_KEM_512_PRIVATE_KEY_SIZE); WC_ML_KEM_512_PRIVATE_KEY_SIZE);
if (ret != 0) if (ret != 0)
ERROR_OUT(WC_TEST_RET_ENC_EC(ret), out); ERROR_OUT(WC_TEST_RET_ENC_EC(ret), out);
@ -39585,7 +39585,7 @@ static wc_test_ret_t kyber512_kat(void)
if (XMEMCMP(priv, ml_kem_512_sk, sizeof(ml_kem_512_sk)) != 0) if (XMEMCMP(priv, ml_kem_512_sk, sizeof(ml_kem_512_sk)) != 0)
ERROR_OUT(WC_TEST_RET_ENC_NC, out); ERROR_OUT(WC_TEST_RET_ENC_NC, out);
ret = wc_KyberKey_EncapsulateWithRandom(key, ct, ss, kyber512enc_rand, ret = wc_MlKem_EncapsulateWithRandom(key, ct, ss, kyber512enc_rand,
sizeof(kyber512enc_rand)); sizeof(kyber512enc_rand));
if (ret != 0) if (ret != 0)
ERROR_OUT(WC_TEST_RET_ENC_EC(ret), out); ERROR_OUT(WC_TEST_RET_ENC_EC(ret), out);
@ -39596,7 +39596,7 @@ static wc_test_ret_t kyber512_kat(void)
if (XMEMCMP(ss, ml_kem_512_ss, sizeof(ml_kem_512_ss)) != 0) if (XMEMCMP(ss, ml_kem_512_ss, sizeof(ml_kem_512_ss)) != 0)
ERROR_OUT(WC_TEST_RET_ENC_NC, out); ERROR_OUT(WC_TEST_RET_ENC_NC, out);
ret = wc_KyberKey_Decapsulate(key, ss_dec, ct, sizeof(ml_kem_512_ct)); ret = wc_MlKem_Decapsulate(key, ss_dec, ct, sizeof(ml_kem_512_ct));
if (ret != 0) if (ret != 0)
ERROR_OUT(WC_TEST_RET_ENC_EC(ret), out); ERROR_OUT(WC_TEST_RET_ENC_EC(ret), out);
@ -39607,7 +39607,7 @@ static wc_test_ret_t kyber512_kat(void)
out: out:
if (key_inited) if (key_inited)
wc_KyberKey_Free(key); wc_MlKem_Free(key);
#ifdef WOLFSSL_SMALL_STACK #ifdef WOLFSSL_SMALL_STACK
XFREE(key, HEAP_HINT, DYNAMIC_TYPE_TMP_BUFFER); XFREE(key, HEAP_HINT, DYNAMIC_TYPE_TMP_BUFFER);
@ -40887,22 +40887,22 @@ static wc_test_ret_t kyber768_kat(void)
#endif #endif
#ifdef WOLFSSL_KYBER_ORIGINAL #ifdef WOLFSSL_KYBER_ORIGINAL
ret = wc_KyberKey_Init(KYBER768, key, HEAP_HINT, INVALID_DEVID); ret = wc_MlKem_Init(KYBER768, key, HEAP_HINT, INVALID_DEVID);
if (ret != 0) if (ret != 0)
ERROR_OUT(WC_TEST_RET_ENC_EC(ret), out); ERROR_OUT(WC_TEST_RET_ENC_EC(ret), out);
else else
key_inited = 1; key_inited = 1;
ret = wc_KyberKey_MakeKeyWithRandom(key, kyber768_rand, ret = wc_MlKem_MakeKeyWithRandom(key, kyber768_rand,
sizeof(kyber768_rand)); sizeof(kyber768_rand));
if (ret != 0) if (ret != 0)
ERROR_OUT(WC_TEST_RET_ENC_EC(ret), out); ERROR_OUT(WC_TEST_RET_ENC_EC(ret), out);
ret = wc_KyberKey_EncodePublicKey(key, pub, KYBER768_PUBLIC_KEY_SIZE); ret = wc_MlKem_EncodePublicKey(key, pub, KYBER768_PUBLIC_KEY_SIZE);
if (ret != 0) if (ret != 0)
ERROR_OUT(WC_TEST_RET_ENC_EC(ret), out); ERROR_OUT(WC_TEST_RET_ENC_EC(ret), out);
ret = wc_KyberKey_EncodePrivateKey(key, priv, KYBER768_PRIVATE_KEY_SIZE); ret = wc_MlKem_EncodePrivateKey(key, priv, KYBER768_PRIVATE_KEY_SIZE);
if (ret != 0) if (ret != 0)
ERROR_OUT(WC_TEST_RET_ENC_EC(ret), out); ERROR_OUT(WC_TEST_RET_ENC_EC(ret), out);
@ -40912,7 +40912,7 @@ static wc_test_ret_t kyber768_kat(void)
if (XMEMCMP(priv, kyber768_sk, sizeof(kyber768_sk)) != 0) if (XMEMCMP(priv, kyber768_sk, sizeof(kyber768_sk)) != 0)
ERROR_OUT(WC_TEST_RET_ENC_NC, out); ERROR_OUT(WC_TEST_RET_ENC_NC, out);
ret = wc_KyberKey_EncapsulateWithRandom(key, ct, ss, kyber768enc_rand, ret = wc_MlKem_EncapsulateWithRandom(key, ct, ss, kyber768enc_rand,
sizeof(kyber768enc_rand)); sizeof(kyber768enc_rand));
if (ret != 0) if (ret != 0)
ERROR_OUT(WC_TEST_RET_ENC_EC(ret), out); ERROR_OUT(WC_TEST_RET_ENC_EC(ret), out);
@ -40923,7 +40923,7 @@ static wc_test_ret_t kyber768_kat(void)
if (XMEMCMP(ss, kyber768_ss, sizeof(kyber768_ss)) != 0) if (XMEMCMP(ss, kyber768_ss, sizeof(kyber768_ss)) != 0)
ERROR_OUT(WC_TEST_RET_ENC_NC, out); ERROR_OUT(WC_TEST_RET_ENC_NC, out);
ret = wc_KyberKey_Decapsulate(key, ss_dec, ct, sizeof(kyber768_ct)); ret = wc_MlKem_Decapsulate(key, ss_dec, ct, sizeof(kyber768_ct));
if (ret != 0) if (ret != 0)
ERROR_OUT(WC_TEST_RET_ENC_EC(ret), out); ERROR_OUT(WC_TEST_RET_ENC_EC(ret), out);
@ -40931,22 +40931,22 @@ static wc_test_ret_t kyber768_kat(void)
ERROR_OUT(WC_TEST_RET_ENC_NC, out); ERROR_OUT(WC_TEST_RET_ENC_NC, out);
#endif #endif
#ifndef WOLFSSL_NO_ML_KEM #ifndef WOLFSSL_NO_ML_KEM
ret = wc_KyberKey_Init(WC_ML_KEM_768, key, HEAP_HINT, INVALID_DEVID); ret = wc_MlKem_Init(WC_ML_KEM_768, key, HEAP_HINT, INVALID_DEVID);
if (ret != 0) if (ret != 0)
ERROR_OUT(WC_TEST_RET_ENC_EC(ret), out); ERROR_OUT(WC_TEST_RET_ENC_EC(ret), out);
else else
key_inited = 1; key_inited = 1;
ret = wc_KyberKey_MakeKeyWithRandom(key, kyber768_rand, ret = wc_MlKem_MakeKeyWithRandom(key, kyber768_rand,
sizeof(kyber768_rand)); sizeof(kyber768_rand));
if (ret != 0) if (ret != 0)
ERROR_OUT(WC_TEST_RET_ENC_EC(ret), out); ERROR_OUT(WC_TEST_RET_ENC_EC(ret), out);
ret = wc_KyberKey_EncodePublicKey(key, pub, WC_ML_KEM_768_PUBLIC_KEY_SIZE); ret = wc_MlKem_EncodePublicKey(key, pub, WC_ML_KEM_768_PUBLIC_KEY_SIZE);
if (ret != 0) if (ret != 0)
ERROR_OUT(WC_TEST_RET_ENC_EC(ret), out); ERROR_OUT(WC_TEST_RET_ENC_EC(ret), out);
ret = wc_KyberKey_EncodePrivateKey(key, priv, ret = wc_MlKem_EncodePrivateKey(key, priv,
WC_ML_KEM_768_PRIVATE_KEY_SIZE); WC_ML_KEM_768_PRIVATE_KEY_SIZE);
if (ret != 0) if (ret != 0)
ERROR_OUT(WC_TEST_RET_ENC_EC(ret), out); ERROR_OUT(WC_TEST_RET_ENC_EC(ret), out);
@ -40957,7 +40957,7 @@ static wc_test_ret_t kyber768_kat(void)
if (XMEMCMP(priv, ml_kem_768_sk, sizeof(ml_kem_768_sk)) != 0) if (XMEMCMP(priv, ml_kem_768_sk, sizeof(ml_kem_768_sk)) != 0)
ERROR_OUT(WC_TEST_RET_ENC_NC, out); ERROR_OUT(WC_TEST_RET_ENC_NC, out);
ret = wc_KyberKey_EncapsulateWithRandom(key, ct, ss, kyber768enc_rand, ret = wc_MlKem_EncapsulateWithRandom(key, ct, ss, kyber768enc_rand,
sizeof(kyber768enc_rand)); sizeof(kyber768enc_rand));
if (ret != 0) if (ret != 0)
ERROR_OUT(WC_TEST_RET_ENC_EC(ret), out); ERROR_OUT(WC_TEST_RET_ENC_EC(ret), out);
@ -40968,7 +40968,7 @@ static wc_test_ret_t kyber768_kat(void)
if (XMEMCMP(ss, ml_kem_768_ss, sizeof(ml_kem_768_ss)) != 0) if (XMEMCMP(ss, ml_kem_768_ss, sizeof(ml_kem_768_ss)) != 0)
ERROR_OUT(WC_TEST_RET_ENC_NC, out); ERROR_OUT(WC_TEST_RET_ENC_NC, out);
ret = wc_KyberKey_Decapsulate(key, ss_dec, ct, sizeof(ml_kem_768_ct)); ret = wc_MlKem_Decapsulate(key, ss_dec, ct, sizeof(ml_kem_768_ct));
if (ret != 0) if (ret != 0)
ERROR_OUT(WC_TEST_RET_ENC_EC(ret), out); ERROR_OUT(WC_TEST_RET_ENC_EC(ret), out);
@ -40979,7 +40979,7 @@ static wc_test_ret_t kyber768_kat(void)
out: out:
if (key_inited) if (key_inited)
wc_KyberKey_Free(key); wc_MlKem_Free(key);
#ifdef WOLFSSL_SMALL_STACK #ifdef WOLFSSL_SMALL_STACK
XFREE(key, HEAP_HINT, DYNAMIC_TYPE_TMP_BUFFER); XFREE(key, HEAP_HINT, DYNAMIC_TYPE_TMP_BUFFER);
@ -42666,22 +42666,22 @@ static wc_test_ret_t kyber1024_kat(void)
#endif #endif
#ifdef WOLFSSL_KYBER_ORIGINAL #ifdef WOLFSSL_KYBER_ORIGINAL
ret = wc_KyberKey_Init(KYBER1024, key, HEAP_HINT, INVALID_DEVID); ret = wc_MlKem_Init(KYBER1024, key, HEAP_HINT, INVALID_DEVID);
if (ret != 0) if (ret != 0)
ERROR_OUT(WC_TEST_RET_ENC_EC(ret), out); ERROR_OUT(WC_TEST_RET_ENC_EC(ret), out);
else else
key_inited = 1; key_inited = 1;
ret = wc_KyberKey_MakeKeyWithRandom(key, kyber1024_rand, ret = wc_MlKem_MakeKeyWithRandom(key, kyber1024_rand,
sizeof(kyber1024_rand)); sizeof(kyber1024_rand));
if (ret != 0) if (ret != 0)
ERROR_OUT(WC_TEST_RET_ENC_EC(ret), out); ERROR_OUT(WC_TEST_RET_ENC_EC(ret), out);
ret = wc_KyberKey_EncodePublicKey(key, pub, KYBER_MAX_PUBLIC_KEY_SIZE); ret = wc_MlKem_EncodePublicKey(key, pub, KYBER_MAX_PUBLIC_KEY_SIZE);
if (ret != 0) if (ret != 0)
ERROR_OUT(WC_TEST_RET_ENC_EC(ret), out); ERROR_OUT(WC_TEST_RET_ENC_EC(ret), out);
ret = wc_KyberKey_EncodePrivateKey(key, priv, KYBER_MAX_PRIVATE_KEY_SIZE); ret = wc_MlKem_EncodePrivateKey(key, priv, KYBER_MAX_PRIVATE_KEY_SIZE);
if (ret != 0) if (ret != 0)
ERROR_OUT(WC_TEST_RET_ENC_EC(ret), out); ERROR_OUT(WC_TEST_RET_ENC_EC(ret), out);
@ -42691,7 +42691,7 @@ static wc_test_ret_t kyber1024_kat(void)
if (XMEMCMP(priv, kyber1024_sk, sizeof(kyber1024_sk)) != 0) if (XMEMCMP(priv, kyber1024_sk, sizeof(kyber1024_sk)) != 0)
ERROR_OUT(WC_TEST_RET_ENC_NC, out); ERROR_OUT(WC_TEST_RET_ENC_NC, out);
ret = wc_KyberKey_EncapsulateWithRandom(key, ct, ss, kyber1024enc_rand, ret = wc_MlKem_EncapsulateWithRandom(key, ct, ss, kyber1024enc_rand,
sizeof(kyber1024enc_rand)); sizeof(kyber1024enc_rand));
if (ret != 0) if (ret != 0)
ERROR_OUT(WC_TEST_RET_ENC_EC(ret), out); ERROR_OUT(WC_TEST_RET_ENC_EC(ret), out);
@ -42702,7 +42702,7 @@ static wc_test_ret_t kyber1024_kat(void)
if (XMEMCMP(ss, kyber1024_ss, sizeof(kyber1024_ss)) != 0) if (XMEMCMP(ss, kyber1024_ss, sizeof(kyber1024_ss)) != 0)
ERROR_OUT(WC_TEST_RET_ENC_NC, out); ERROR_OUT(WC_TEST_RET_ENC_NC, out);
ret = wc_KyberKey_Decapsulate(key, ss_dec, ct, sizeof(kyber1024_ct)); ret = wc_MlKem_Decapsulate(key, ss_dec, ct, sizeof(kyber1024_ct));
if (ret != 0) if (ret != 0)
ERROR_OUT(WC_TEST_RET_ENC_EC(ret), out); ERROR_OUT(WC_TEST_RET_ENC_EC(ret), out);
@ -42710,22 +42710,22 @@ static wc_test_ret_t kyber1024_kat(void)
ERROR_OUT(WC_TEST_RET_ENC_NC, out); ERROR_OUT(WC_TEST_RET_ENC_NC, out);
#endif #endif
#ifndef WOLFSSL_NO_ML_KEM #ifndef WOLFSSL_NO_ML_KEM
ret = wc_KyberKey_Init(WC_ML_KEM_1024, key, HEAP_HINT, INVALID_DEVID); ret = wc_MlKem_Init(WC_ML_KEM_1024, key, HEAP_HINT, INVALID_DEVID);
if (ret != 0) if (ret != 0)
ERROR_OUT(WC_TEST_RET_ENC_EC(ret), out); ERROR_OUT(WC_TEST_RET_ENC_EC(ret), out);
else else
key_inited = 1; key_inited = 1;
ret = wc_KyberKey_MakeKeyWithRandom(key, kyber1024_rand, ret = wc_MlKem_MakeKeyWithRandom(key, kyber1024_rand,
sizeof(kyber1024_rand)); sizeof(kyber1024_rand));
if (ret != 0) if (ret != 0)
ERROR_OUT(WC_TEST_RET_ENC_EC(ret), out); ERROR_OUT(WC_TEST_RET_ENC_EC(ret), out);
ret = wc_KyberKey_EncodePublicKey(key, pub, WC_ML_KEM_MAX_PUBLIC_KEY_SIZE); ret = wc_MlKem_EncodePublicKey(key, pub, WC_ML_KEM_MAX_PUBLIC_KEY_SIZE);
if (ret != 0) if (ret != 0)
ERROR_OUT(WC_TEST_RET_ENC_EC(ret), out); ERROR_OUT(WC_TEST_RET_ENC_EC(ret), out);
ret = wc_KyberKey_EncodePrivateKey(key, priv, ret = wc_MlKem_EncodePrivateKey(key, priv,
WC_ML_KEM_MAX_PRIVATE_KEY_SIZE); WC_ML_KEM_MAX_PRIVATE_KEY_SIZE);
if (ret != 0) if (ret != 0)
ERROR_OUT(WC_TEST_RET_ENC_EC(ret), out); ERROR_OUT(WC_TEST_RET_ENC_EC(ret), out);
@ -42736,7 +42736,7 @@ static wc_test_ret_t kyber1024_kat(void)
if (XMEMCMP(priv, ml_kem_1024_sk, sizeof(ml_kem_1024_sk)) != 0) if (XMEMCMP(priv, ml_kem_1024_sk, sizeof(ml_kem_1024_sk)) != 0)
ERROR_OUT(WC_TEST_RET_ENC_NC, out); ERROR_OUT(WC_TEST_RET_ENC_NC, out);
ret = wc_KyberKey_EncapsulateWithRandom(key, ct, ss, kyber1024enc_rand, ret = wc_MlKem_EncapsulateWithRandom(key, ct, ss, kyber1024enc_rand,
sizeof(kyber1024enc_rand)); sizeof(kyber1024enc_rand));
if (ret != 0) if (ret != 0)
ERROR_OUT(WC_TEST_RET_ENC_EC(ret), out); ERROR_OUT(WC_TEST_RET_ENC_EC(ret), out);
@ -42747,7 +42747,7 @@ static wc_test_ret_t kyber1024_kat(void)
if (XMEMCMP(ss, ml_kem_1024_ss, sizeof(ml_kem_1024_ss)) != 0) if (XMEMCMP(ss, ml_kem_1024_ss, sizeof(ml_kem_1024_ss)) != 0)
ERROR_OUT(WC_TEST_RET_ENC_NC, out); ERROR_OUT(WC_TEST_RET_ENC_NC, out);
ret = wc_KyberKey_Decapsulate(key, ss_dec, ct, sizeof(ml_kem_1024_ct)); ret = wc_MlKem_Decapsulate(key, ss_dec, ct, sizeof(ml_kem_1024_ct));
if (ret != 0) if (ret != 0)
ERROR_OUT(WC_TEST_RET_ENC_EC(ret), out); ERROR_OUT(WC_TEST_RET_ENC_EC(ret), out);
@ -42758,7 +42758,7 @@ static wc_test_ret_t kyber1024_kat(void)
out: out:
if (key_inited) if (key_inited)
wc_KyberKey_Free(key); wc_MlKem_Free(key);
#ifdef WOLFSSL_SMALL_STACK #ifdef WOLFSSL_SMALL_STACK
XFREE(key, HEAP_HINT, DYNAMIC_TYPE_TMP_BUFFER); XFREE(key, HEAP_HINT, DYNAMIC_TYPE_TMP_BUFFER);
@ -42862,59 +42862,59 @@ WOLFSSL_TEST_SUBROUTINE wc_test_ret_t kyber_test(void)
ERROR_OUT(WC_TEST_RET_ENC_EC(ret), out); ERROR_OUT(WC_TEST_RET_ENC_EC(ret), out);
for (i = 0; i < (int)(sizeof(testData) / sizeof(*testData)); i++) { for (i = 0; i < (int)(sizeof(testData) / sizeof(*testData)); i++) {
ret = wc_KyberKey_Init(testData[i][0], key, HEAP_HINT, INVALID_DEVID); ret = wc_MlKem_Init(testData[i][0], key, HEAP_HINT, INVALID_DEVID);
if (ret != 0) if (ret != 0)
ERROR_OUT(WC_TEST_RET_ENC_I(i), out); ERROR_OUT(WC_TEST_RET_ENC_I(i), out);
else else
key_inited = 1; key_inited = 1;
ret = wc_KyberKey_MakeKey(key, &rng); ret = wc_MlKem_MakeKey(key, &rng);
if (ret != 0) if (ret != 0)
ERROR_OUT(WC_TEST_RET_ENC_I(i), out); ERROR_OUT(WC_TEST_RET_ENC_I(i), out);
ret = wc_KyberKey_EncodePublicKey(key, pub, testData[i][2]); ret = wc_MlKem_EncodePublicKey(key, pub, testData[i][2]);
if (ret != 0) if (ret != 0)
ERROR_OUT(WC_TEST_RET_ENC_I(i), out); ERROR_OUT(WC_TEST_RET_ENC_I(i), out);
ret = wc_KyberKey_EncodePrivateKey(key, priv, testData[i][1]); ret = wc_MlKem_EncodePrivateKey(key, priv, testData[i][1]);
if (ret != 0) if (ret != 0)
ERROR_OUT(WC_TEST_RET_ENC_I(i), out); ERROR_OUT(WC_TEST_RET_ENC_I(i), out);
ret = wc_KyberKey_Init(testData[i][0], key, HEAP_HINT, INVALID_DEVID); ret = wc_MlKem_Init(testData[i][0], key, HEAP_HINT, INVALID_DEVID);
if (ret != 0) if (ret != 0)
ERROR_OUT(WC_TEST_RET_ENC_I(i), out); ERROR_OUT(WC_TEST_RET_ENC_I(i), out);
ret = wc_KyberKey_DecodePublicKey(key, pub, testData[i][2]); ret = wc_MlKem_DecodePublicKey(key, pub, testData[i][2]);
if (ret != 0) if (ret != 0)
ERROR_OUT(WC_TEST_RET_ENC_I(i), out); ERROR_OUT(WC_TEST_RET_ENC_I(i), out);
ret = wc_KyberKey_Encapsulate(key, ct, ss, &rng); ret = wc_MlKem_Encapsulate(key, ct, ss, &rng);
if (ret != 0) if (ret != 0)
ERROR_OUT(WC_TEST_RET_ENC_I(i), out); ERROR_OUT(WC_TEST_RET_ENC_I(i), out);
ret = wc_KyberKey_EncodePublicKey(key, pub2, testData[i][2]); ret = wc_MlKem_EncodePublicKey(key, pub2, testData[i][2]);
if (ret != 0) if (ret != 0)
ERROR_OUT(WC_TEST_RET_ENC_I(i), out); ERROR_OUT(WC_TEST_RET_ENC_I(i), out);
if (XMEMCMP(pub, pub2, testData[i][2]) != 0) if (XMEMCMP(pub, pub2, testData[i][2]) != 0)
ERROR_OUT(WC_TEST_RET_ENC_I(i), out); ERROR_OUT(WC_TEST_RET_ENC_I(i), out);
ret = wc_KyberKey_Init(testData[i][0], key, HEAP_HINT, INVALID_DEVID); ret = wc_MlKem_Init(testData[i][0], key, HEAP_HINT, INVALID_DEVID);
if (ret != 0) if (ret != 0)
ERROR_OUT(WC_TEST_RET_ENC_I(i), out); ERROR_OUT(WC_TEST_RET_ENC_I(i), out);
ret = wc_KyberKey_DecodePrivateKey(key, priv, testData[i][1]); ret = wc_MlKem_DecodePrivateKey(key, priv, testData[i][1]);
if (ret != 0) if (ret != 0)
ERROR_OUT(WC_TEST_RET_ENC_I(i), out); ERROR_OUT(WC_TEST_RET_ENC_I(i), out);
ret = wc_KyberKey_Decapsulate(key, ss_dec, ct, testData[i][3]); ret = wc_MlKem_Decapsulate(key, ss_dec, ct, testData[i][3]);
if (ret != 0) if (ret != 0)
ERROR_OUT(WC_TEST_RET_ENC_I(i), out); ERROR_OUT(WC_TEST_RET_ENC_I(i), out);
if (XMEMCMP(ss, ss_dec, KYBER_SS_SZ) != 0) if (XMEMCMP(ss, ss_dec, KYBER_SS_SZ) != 0)
ERROR_OUT(WC_TEST_RET_ENC_I(i), out); ERROR_OUT(WC_TEST_RET_ENC_I(i), out);
ret = wc_KyberKey_EncodePrivateKey(key, priv2, testData[i][1]); ret = wc_MlKem_EncodePrivateKey(key, priv2, testData[i][1]);
if (ret != 0) if (ret != 0)
ERROR_OUT(WC_TEST_RET_ENC_I(i), out); ERROR_OUT(WC_TEST_RET_ENC_I(i), out);
@ -42945,7 +42945,7 @@ WOLFSSL_TEST_SUBROUTINE wc_test_ret_t kyber_test(void)
out: out:
if (key_inited) if (key_inited)
wc_KyberKey_Free(key); wc_MlKem_Free(key);
#ifdef WOLFSSL_SMALL_STACK #ifdef WOLFSSL_SMALL_STACK
XFREE(key, HEAP_HINT, DYNAMIC_TYPE_TMP_BUFFER); XFREE(key, HEAP_HINT, DYNAMIC_TYPE_TMP_BUFFER);

60
wolfssl/wolfcrypt/kyber.h
View File

@ -188,34 +188,34 @@ typedef struct KyberKey KyberKey;
extern "C" { extern "C" {
#endif #endif
WOLFSSL_API int wc_KyberKey_Init(int type, KyberKey* key, void* heap, WOLFSSL_API int wc_MlKem_Init(int type, KyberKey* key, void* heap,
int devId); int devId);
WOLFSSL_API void wc_KyberKey_Free(KyberKey* key); WOLFSSL_API void wc_MlKem_Free(KyberKey* key);
WOLFSSL_API int wc_KyberKey_MakeKey(KyberKey* key, WC_RNG* rng); WOLFSSL_API int wc_MlKem_MakeKey(KyberKey* key, WC_RNG* rng);
WOLFSSL_API int wc_KyberKey_MakeKeyWithRandom(KyberKey* key, WOLFSSL_API int wc_MlKem_MakeKeyWithRandom(KyberKey* key,
const unsigned char* rand, int len); const unsigned char* rand, int len);
WOLFSSL_API int wc_KyberKey_CipherTextSize(KyberKey* key, word32* len); WOLFSSL_API int wc_MlKem_CipherTextSize(KyberKey* key, word32* len);
WOLFSSL_API int wc_KyberKey_SharedSecretSize(KyberKey* key, word32* len); WOLFSSL_API int wc_MlKem_SharedSecretSize(KyberKey* key, word32* len);
WOLFSSL_API int wc_KyberKey_Encapsulate(KyberKey* key, unsigned char* ct, WOLFSSL_API int wc_MlKem_Encapsulate(KyberKey* key, unsigned char* ct,
unsigned char* ss, WC_RNG* rng); unsigned char* ss, WC_RNG* rng);
WOLFSSL_API int wc_KyberKey_EncapsulateWithRandom(KyberKey* key, WOLFSSL_API int wc_MlKem_EncapsulateWithRandom(KyberKey* key,
unsigned char* ct, unsigned char* ss, const unsigned char* rand, int len); unsigned char* ct, unsigned char* ss, const unsigned char* rand, int len);
WOLFSSL_API int wc_KyberKey_Decapsulate(KyberKey* key, unsigned char* ss, WOLFSSL_API int wc_MlKem_Decapsulate(KyberKey* key, unsigned char* ss,
const unsigned char* ct, word32 len); const unsigned char* ct, word32 len);
WOLFSSL_API int wc_KyberKey_DecodePrivateKey(KyberKey* key, WOLFSSL_API int wc_MlKem_DecodePrivateKey(KyberKey* key,
const unsigned char* in, word32 len); const unsigned char* in, word32 len);
WOLFSSL_API int wc_KyberKey_DecodePublicKey(KyberKey* key, WOLFSSL_API int wc_MlKem_DecodePublicKey(KyberKey* key,
const unsigned char* in, word32 len); const unsigned char* in, word32 len);
WOLFSSL_API int wc_KyberKey_PrivateKeySize(KyberKey* key, word32* len); WOLFSSL_API int wc_MlKem_PrivateKeySize(KyberKey* key, word32* len);
WOLFSSL_API int wc_KyberKey_PublicKeySize(KyberKey* key, word32* len); WOLFSSL_API int wc_MlKem_PublicKeySize(KyberKey* key, word32* len);
WOLFSSL_API int wc_KyberKey_EncodePrivateKey(KyberKey* key, unsigned char* out, WOLFSSL_API int wc_MlKem_EncodePrivateKey(KyberKey* key, unsigned char* out,
word32 len); word32 len);
WOLFSSL_API int wc_KyberKey_EncodePublicKey(KyberKey* key, unsigned char* out, WOLFSSL_API int wc_MlKem_EncodePublicKey(KyberKey* key, unsigned char* out,
word32 len); word32 len);
@ -271,21 +271,21 @@ WOLFSSL_API int wc_KyberKey_EncodePublicKey(KyberKey* key, unsigned char* out,
#define MlKemKey KyberKey #define MlKemKey KyberKey
#define wc_MlKemKey_Init(key, type, heap, devId) \ #define wc_MlKemKey_Init(key, type, heap, devId) \
wc_KyberKey_Init(type, key, heap, devId) wc_MlKem_Init(type, key, heap, devId)
#define wc_MlKemKey_Free wc_KyberKey_Free #define wc_MlKemKey_Free wc_MlKem_Free
#define wc_MlKemKey_MakeKey wc_KyberKey_MakeKey #define wc_MlKemKey_MakeKey wc_MlKem_MakeKey
#define wc_MlKemKey_MakeKeyWithRandom wc_KyberKey_MakeKeyWithRandom #define wc_MlKemKey_MakeKeyWithRandom wc_MlKem_MakeKeyWithRandom
#define wc_MlKemKey_CipherTextSize wc_KyberKey_CipherTextSize #define wc_MlKemKey_CipherTextSize wc_MlKem_CipherTextSize
#define wc_MlKemKey_SharedSecretSize wc_KyberKey_SharedSecretSize #define wc_MlKemKey_SharedSecretSize wc_MlKem_SharedSecretSize
#define wc_MlKemKey_Encapsulate wc_KyberKey_Encapsulate #define wc_MlKemKey_Encapsulate wc_MlKem_Encapsulate
#define wc_MlKemKey_EncapsulateWithRandom wc_KyberKey_EncapsulateWithRandom #define wc_MlKemKey_EncapsulateWithRandom wc_MlKem_EncapsulateWithRandom
#define wc_MlKemKey_Decapsulate wc_KyberKey_Decapsulate #define wc_MlKemKey_Decapsulate wc_MlKem_Decapsulate
#define wc_MlKemKey_DecodePrivateKey wc_KyberKey_DecodePrivateKey #define wc_MlKemKey_DecodePrivateKey wc_MlKem_DecodePrivateKey
#define wc_MlKemKey_DecodePublicKey wc_KyberKey_DecodePublicKey #define wc_MlKemKey_DecodePublicKey wc_MlKem_DecodePublicKey
#define wc_MlKemKey_PrivateKeySize wc_KyberKey_PrivateKeySize #define wc_MlKemKey_PrivateKeySize wc_MlKem_PrivateKeySize
#define wc_MlKemKey_PublicKeySize wc_KyberKey_PublicKeySize #define wc_MlKemKey_PublicKeySize wc_MlKem_PublicKeySize
#define wc_MlKemKey_EncodePrivateKey wc_KyberKey_EncodePrivateKey #define wc_MlKemKey_EncodePrivateKey wc_MlKem_EncodePrivateKey
#define wc_MlKemKey_EncodePublicKey wc_KyberKey_EncodePublicKey #define wc_MlKemKey_EncodePublicKey wc_MlKem_EncodePublicKey
#ifdef __cplusplus #ifdef __cplusplus