diff --git a/.github/workflows/build-workflow.yml b/.github/workflows/build-workflow.yml index 124e063c..c795540b 100644 --- a/.github/workflows/build-workflow.yml +++ b/.github/workflows/build-workflow.yml @@ -11,6 +11,14 @@ on: required: false type: string default: 'make check' + wolfssl_config: + required: false + type: string + default: '' + wolfssl_cflags: + required: false + type: string + default: '' jobs: build: @@ -36,7 +44,8 @@ jobs: working-directory: ./wolfssl run: | ./configure --enable-cryptocb --enable-aescfb --enable-rsapss --enable-keygen --enable-pwdbased --enable-scrypt --enable-md5 \ - --enable-mldsa --enable-lms=verify-only --enable-xmss=verify-only C_EXTRA_FLAGS="-DWOLFSSL_PUBLIC_MP -DWC_RSA_DIRECT -DHAVE_AES_ECB -DHAVE_AES_KEYWRAP" + --enable-mldsa --enable-lms=verify-only --enable-xmss=verify-only ${{inputs.wolfssl_config}} \ + C_EXTRA_FLAGS="-DWOLFSSL_PUBLIC_MP -DWC_RSA_DIRECT -DHAVE_AES_ECB -DHAVE_AES_KEYWRAP ${{inputs.wolfssl_cflags}}" - name: wolfssl make working-directory: ./wolfssl run: make diff --git a/.github/workflows/unit-test.yml b/.github/workflows/unit-test.yml index 865a5875..ea69a25d 100644 --- a/.github/workflows/unit-test.yml +++ b/.github/workflows/unit-test.yml @@ -103,6 +103,16 @@ jobs: uses: ./.github/workflows/build-workflow.yml with: config: --disable-hmac --disable-hkdf + no_concatenate: + uses: ./.github/workflows/build-workflow.yml + with: + config: --disable-concatenate + no_derive_secret_key: + uses: ./.github/workflows/build-workflow.yml + with: + config: --disable-ecc --disable-dh --disable-hkdf --disable-aescbc --disable-concatenate + wolfssl_config: --enable-cryptonly --disable-crypttests --disable-examples + wolfssl_cflags: -DNO_KDF with_nss: uses: ./.github/workflows/build-workflow.yml with: diff --git a/CMakeLists.txt b/CMakeLists.txt index 4659d46a..08589d33 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -330,6 +330,16 @@ if(WOLFPKCS11_HKDF) endif() +# Concatenation key derivation +add_option("WOLFPKCS11_CONCATENATE" + "Enable wolfPKCS11 CKM_CONCATENATE_* key derivation (default: enabled)" + "yes" "yes;no") + +if(WOLFPKCS11_CONCATENATE) + list(APPEND WOLFPKCS11_DEFINITIONS "-DWOLFPKCS11_CONCATENATE") +endif() + + # PBKDF2 add_option("WOLFPKCS11_PBKDF2" "Enable wolfPKCS11 PBKDF2 support (default: disabled)" diff --git a/IDE/VisualStudio/user_settings.h b/IDE/VisualStudio/user_settings.h index 101221fd..ddf17e05 100644 --- a/IDE/VisualStudio/user_settings.h +++ b/IDE/VisualStudio/user_settings.h @@ -73,6 +73,7 @@ extern "C" { #define WOLFSSL_KEY_GEN //#define HAVE_SCRYPT /* For PKCS11 Pin. Scrypt uses massive memory */ //#define WOLFPKCS11_USER_ENV +#define WOLFPKCS11_CONCATENATE /* PKCS11 TPM */ #define WOLFPKCS11_TPM diff --git a/README.md b/README.md index 2700bea6..dcd9597b 100644 --- a/README.md +++ b/README.md @@ -311,6 +311,7 @@ cmake -DCMAKE_PREFIX_PATH=/path/to/wolfssl/install .. | `WOLFPKCS11_AESCMAC` | `no` | AES-CMAC support | | `WOLFPKCS11_HMAC` | `yes` | HMAC support | | `WOLFPKCS11_HKDF` | `yes` | HKDF support | +| `WOLFPKCS11_CONCATENATE` | `yes` | `CKM_CONCATENATE_*` key derivation | | `WOLFPKCS11_PBKDF2` | `no` | PBKDF2 for PIN hashing | | `PBKDF2_ITERATIONS` | `600000` | PBKDF2 iteration count (used when `WOLFPKCS11_PBKDF2=yes`) | | `WOLFPKCS11_MD5` | `yes` | MD5 support | diff --git a/cmake/options.h.in b/cmake/options.h.in index 14e5d04f..a4d7ac9e 100644 --- a/cmake/options.h.in +++ b/cmake/options.h.in @@ -74,6 +74,8 @@ extern "C" { #cmakedefine NO_HMAC #undef WOLFPKCS11_HKDF #cmakedefine WOLFPKCS11_HKDF +#undef WOLFPKCS11_CONCATENATE +#cmakedefine WOLFPKCS11_CONCATENATE #undef WOLFPKCS11_PBKDF2 #cmakedefine WOLFPKCS11_PBKDF2 #undef PBKDF2_ITERATIONS diff --git a/configure.ac b/configure.ac index 569d38d7..e99c0711 100644 --- a/configure.ac +++ b/configure.ac @@ -336,6 +336,16 @@ then AM_CFLAGS="$AM_CFLAGS -DWOLFPKCS11_HKDF" fi +AC_ARG_ENABLE([concatenate], + [AS_HELP_STRING([--enable-concatenate],[Enable CKM_CONCATENATE_* key derivation (default: enabled)])], + [ ENABLED_CONCATENATE=$enableval ], + [ ENABLED_CONCATENATE=yes ] + ) +if test "$ENABLED_CONCATENATE" = "yes" +then + AM_CFLAGS="$AM_CFLAGS -DWOLFPKCS11_CONCATENATE" +fi + AC_ARG_ENABLE([pbkdf2], [AS_HELP_STRING([--enable-pbkdf2],[Enable internal PBKDF2 for PIN hashing (default: disabled)])], [ ENABLED_PBKDF2=$enableval ], @@ -851,6 +861,7 @@ echo " * RSA-PSS: $ENABLED_RSAPSS" echo " * DH: $ENABLED_DH" echo " * ECC: $ENABLED_ECC" echo " * HKDF: $ENABLED_HKDF" +echo " * Concatenate derive: $ENABLED_CONCATENATE" echo " * ML-DSA: $ENABLED_MLDSA" echo " * ML-KEM: $ENABLED_MLKEM" echo " * LMS/HSS verify: $ENABLED_LMS" diff --git a/src/crypto.c b/src/crypto.c index c6ff2a32..6ac7e74c 100644 --- a/src/crypto.c +++ b/src/crypto.c @@ -54,6 +54,13 @@ #define PRF_KEY_SIZE 48 +/* Derive mechanisms that build their output into a secret key object. */ +#if defined(HAVE_ECC) || !defined(NO_DH) || defined(WOLFPKCS11_HKDF) || \ + (!defined(NO_AES) && defined(HAVE_AES_CBC)) || \ + defined(WOLFSSL_HAVE_PRF) || defined(WOLFPKCS11_CONCATENATE) + #define WP11_DERIVE_SECRET_KEY +#endif + /* Check that a CK_ULONG value fits in word32 with room for overhead such as * authentication tags, key wrap blocks, or padding. On LP64 platforms CK_ULONG * is 64-bit but wolfCrypt functions use word32/int for lengths. */ @@ -650,6 +657,7 @@ static CK_RV SetInitialStates(WP11_Object* key) return rv; } +#ifdef WP11_DERIVE_SECRET_KEY /* PKCS#11 derive rules: the historical flags also need the base key's. */ static CK_RV SetDerivedStates(WP11_Object* key, CK_BBOOL baseAlwaysSensitive, CK_BBOOL baseNeverExtractable) @@ -678,6 +686,7 @@ static CK_RV SetDerivedStates(WP11_Object* key, CK_BBOOL baseAlwaysSensitive, } return rv; } +#endif static CK_RV TemplateHasAttribute(CK_ATTRIBUTE_TYPE type, CK_ATTRIBUTE_PTR pTemplate, CK_ULONG ulCount) @@ -10164,6 +10173,7 @@ CK_RV C_UnwrapKey(CK_SESSION_HANDLE hSession, return rv; } +#ifdef WP11_DERIVE_SECRET_KEY /** * Determine the key length of the object. * @@ -10213,6 +10223,7 @@ static int SymmKeyLen(WP11_Object* obj, word32 len, CK_ULONG* symmKeyLen) return ret; } +#endif #ifdef WOLFSSL_HAVE_PRF static int SetKeyExtract(WP11_Session* session, byte* ptr, CK_ULONG length, @@ -10365,6 +10376,7 @@ static int Tls12_Extract_Keys(WP11_Session* session, } #endif +#ifdef WOLFPKCS11_CONCATENATE static CK_RV ConcatKeyRv(WP11_Session* session, int ret) { if (ret == 0) @@ -10394,6 +10406,7 @@ static int ConcatCutsProtectedKey(WP11_Object* key, CK_ULONG off, extractable = CK_FALSE; return sensitive == CK_TRUE || extractable == CK_FALSE; } +#endif /** * Generate a symmetric key into a new key object. @@ -10437,6 +10450,7 @@ static CK_RV wp11_C_DeriveKey(CK_SESSION_HANDLE hSession, CK_RV rv = CKR_OK; WP11_Session* session; WP11_Object* obj = NULL; +#ifdef WP11_DERIVE_SECRET_KEY WP11_Object* otherKey = NULL; byte* derivedKey = NULL; word32 keyLen; @@ -10463,6 +10477,7 @@ static CK_RV wp11_C_DeriveKey(CK_SESSION_HANDLE hSession, #if !defined(NO_AES) && !defined(WOLFPKCS11_NSS) CK_ATTRIBUTE* keyTypeAttr = NULL; #endif +#endif #ifndef NO_DH CK_ULONG dhPrimeLen = 0; #endif @@ -10873,6 +10888,7 @@ static CK_RV wp11_C_DeriveKey(CK_SESSION_HANDLE hSession, } #endif #endif +#ifdef WOLFPKCS11_CONCATENATE case CKM_CONCATENATE_BASE_AND_KEY: case CKM_CONCATENATE_BASE_AND_DATA: case CKM_CONCATENATE_DATA_AND_BASE: { @@ -10982,11 +10998,13 @@ static CK_RV wp11_C_DeriveKey(CK_SESSION_HANDLE hSession, rv = ConcatKeyRv(session, ret); break; } +#endif default: (void)ulAttributeCount; return CKR_MECHANISM_INVALID; } +#ifdef WP11_DERIVE_SECRET_KEY if ((ret == 0) && (derivedKey != NULL)) { /* F-4533: read the base key's protection bits while `obj' still * refers to it, before CreateObject reuses `obj' for the new key. */ @@ -11132,6 +11150,7 @@ static CK_RV wp11_C_DeriveKey(CK_SESSION_HANDLE hSession, wc_ForceZero(derivedKey, keyLen); XFREE(derivedKey, NULL, DYNAMIC_TYPE_TMP_BUFFER); } +#endif return rv; } diff --git a/src/internal.c b/src/internal.c index 57715039..23ce6bc5 100644 --- a/src/internal.c +++ b/src/internal.c @@ -19174,6 +19174,7 @@ int WP11_KDF_Derive(WP11_Session* session, CK_HKDF_PARAMS_PTR params, #endif +#ifdef WOLFPKCS11_CONCATENATE /* Call with the object lock held when the key is on the token. */ static int wp11_Concat_KeyState(WP11_Object* key) { @@ -19294,6 +19295,7 @@ int WP11_Concat_Derive(WP11_Object* base, WP11_Object* other, ret = BAD_FUNC_ARG; return ret; } +#endif /* WOLFPKCS11_CONCATENATE */ #ifndef NO_DH /** diff --git a/src/slot.c b/src/slot.c index 5816a361..b1718af0 100644 --- a/src/slot.c +++ b/src/slot.c @@ -497,9 +497,11 @@ static CK_MECHANISM_TYPE mechanismList[] = { CKM_TLS_MAC, #endif CKM_GENERIC_SECRET_KEY_GEN, +#ifdef WOLFPKCS11_CONCATENATE CKM_CONCATENATE_BASE_AND_KEY, CKM_CONCATENATE_BASE_AND_DATA, CKM_CONCATENATE_DATA_AND_BASE, +#endif #ifndef NO_HMAC CKM_PKCS5_PBKD2 #endif @@ -912,9 +914,11 @@ static CK_MECHANISM_INFO sha3MechInfo = { static CK_MECHANISM_INFO genSecKeyGenMechInfo = { 8, WP11_MAX_SYM_KEY_SZ * 8, CKF_GENERATE }; +#ifdef WOLFPKCS11_CONCATENATE static CK_MECHANISM_INFO concatMechInfo = { 8, WP11_MAX_SYM_KEY_SZ * 8, CKF_DERIVE }; +#endif #ifndef NO_HMAC static CK_MECHANISM_INFO pkcs5Pbkdf2MechInfo = { @@ -1299,11 +1303,13 @@ CK_RV C_GetMechanismInfo(CK_SLOT_ID slotID, CK_MECHANISM_TYPE type, XMEMCPY(pInfo, &genSecKeyGenMechInfo, sizeof(CK_MECHANISM_INFO)); break; +#ifdef WOLFPKCS11_CONCATENATE case CKM_CONCATENATE_BASE_AND_KEY: case CKM_CONCATENATE_BASE_AND_DATA: case CKM_CONCATENATE_DATA_AND_BASE: XMEMCPY(pInfo, &concatMechInfo, sizeof(CK_MECHANISM_INFO)); break; +#endif #ifndef NO_HMAC case CKM_PKCS5_PBKD2: XMEMCPY(pInfo, &pkcs5Pbkdf2MechInfo, diff --git a/tests/decrypt_final_bufsize_test.c b/tests/decrypt_final_bufsize_test.c index 19006e14..7b5bf5ac 100644 --- a/tests/decrypt_final_bufsize_test.c +++ b/tests/decrypt_final_bufsize_test.c @@ -50,6 +50,7 @@ #define TEST_DIR "./store/decrypt_final_bufsize_test" +#if !defined(NO_AES) && !defined(NO_AES_CBC) static int run_test(void) { CK_RV rv; @@ -182,6 +183,7 @@ static int run_test(void) pkcs11_unload(); return 0; } +#endif int main(int argc, char* argv[]) { @@ -193,6 +195,10 @@ int main(int argc, char* argv[]) #endif printf("=== wolfPKCS11 C_DecryptFinal CBC-PAD buffer-size test ===\n"); +#if !defined(NO_AES) && !defined(NO_AES_CBC) run_test(); +#else + printf("AES-CBC not available, skipping\n"); +#endif return pkcs11_test_summary(); } diff --git a/tests/object_store_decode_test.c b/tests/object_store_decode_test.c index 74fcdb2f..76243df9 100644 --- a/tests/object_store_decode_test.c +++ b/tests/object_store_decode_test.c @@ -1134,7 +1134,7 @@ static CK_RV create_aes_key(CK_SESSION_HANDLE session) } #endif -#ifndef NO_AES +#if !defined(NO_AES) && !defined(NO_AES_CBC) /* Count the AES keys visible after a login and check one still encrypts. */ static CK_RV use_stored_aes_key(CK_SESSION_HANDLE session) { @@ -1259,7 +1259,7 @@ int main(int argc, char* argv[]) #ifdef HAVE_ALLOC_TRACKING test_failed_decrypt_scrubbed(); test_failed_key_decrypt_scrubbed(); -#ifndef NO_AES +#if !defined(NO_AES) && !defined(NO_AES_CBC) test_login_after_failed_encode(); #endif #endif diff --git a/tests/pkcs11mtt.c b/tests/pkcs11mtt.c index d9572747..182dccf1 100644 --- a/tests/pkcs11mtt.c +++ b/tests/pkcs11mtt.c @@ -73,9 +73,7 @@ static CK_OBJECT_CLASS pubKeyClass = CKO_PUBLIC_KEY; static CK_OBJECT_CLASS privKeyClass = CKO_PRIVATE_KEY; static CK_OBJECT_CLASS secretKeyClass = CKO_SECRET_KEY; -#if defined(HAVE_ECC) || !defined(NO_DH) static CK_BBOOL ckFalse = CK_FALSE; -#endif static CK_BBOOL ckTrue = CK_TRUE; #ifndef NO_RSA diff --git a/tests/pkcs11str.c b/tests/pkcs11str.c index b0b5d74d..41e5a016 100644 --- a/tests/pkcs11str.c +++ b/tests/pkcs11str.c @@ -1088,15 +1088,24 @@ static CK_RV undecoded_key_before_login(void) { CK_RV ret; CK_OBJECT_CLASS keyClass = CKO_SECRET_KEY; - CK_BBOOL ckFalse = CK_FALSE; CK_SESSION_HANDLE session = CK_INVALID_HANDLE; CK_OBJECT_HANDLE key = CK_INVALID_HANDLE; - CK_OBJECT_HANDLE derived = CK_INVALID_HANDLE; CK_ULONG count = 0; +#ifdef WOLFPKCS11_CONCATENATE + CK_BBOOL ckFalse = CK_FALSE; + CK_OBJECT_HANDLE derived = CK_INVALID_HANDLE; unsigned char data[4] = { 0xd0, 0xd1, 0xd2, 0xd3 }; CK_KEY_DERIVATION_STRING_DATA params = { data, sizeof(data) }; CK_MECHANISM mech = { CKM_CONCATENATE_BASE_AND_DATA, ¶ms, sizeof(params) }; + CK_ULONG valueLen = 16 + sizeof(data); + CK_ATTRIBUTE tmpl[] = { + { CKA_CLASS, &keyClass, sizeof(keyClass) }, + { CKA_KEY_TYPE, &genericKeyType, sizeof(genericKeyType) }, + { CKA_PRIVATE, &ckFalse, sizeof(ckFalse) }, + { CKA_VALUE_LEN, &valueLen, sizeof(valueLen) }, + }; +#endif #ifndef NO_HMAC CK_MECHANISM macMech = { CKM_SHA256_HMAC, NULL, 0 }; #endif @@ -1119,15 +1128,8 @@ static CK_RV undecoded_key_before_login(void) CK_ATTRIBUTE primeTmpl = { CKA_PRIME, prime, sizeof(prime) }; CK_ATTRIBUTE dhValueTmpl = { CKA_VALUE, dhValue, sizeof(dhValue) }; #endif - CK_ULONG valueLen = 16 + sizeof(data); CK_ULONG keyLen = 0; CK_ATTRIBUTE lenTmpl = { CKA_VALUE_LEN, &keyLen, sizeof(keyLen) }; - CK_ATTRIBUTE tmpl[] = { - { CKA_CLASS, &keyClass, sizeof(keyClass) }, - { CKA_KEY_TYPE, &genericKeyType, sizeof(genericKeyType) }, - { CKA_PRIVATE, &ckFalse, sizeof(ckFalse) }, - { CKA_VALUE_LEN, &valueLen, sizeof(valueLen) }, - }; ret = funcList->C_OpenSession(slot, CKF_SERIAL_SESSION | CKF_RW_SESSION, NULL, NULL, &session); @@ -1152,12 +1154,14 @@ static CK_RV undecoded_key_before_login(void) } CHECK_COND(ret != CKR_OK || keyLen == 16, ret, "Key length value before login"); +#ifdef WOLFPKCS11_CONCATENATE if (ret == CKR_OK) { ret = funcList->C_DeriveKey(session, &mech, key, tmpl, sizeof(tmpl) / sizeof(*tmpl), &derived); CHECK_CKR_FAIL(ret, CKR_USER_NOT_LOGGED_IN, "Concatenate undecoded key before login"); } +#endif #ifndef NO_HMAC if (ret == CKR_OK) { ret = funcList->C_SignInit(session, &macMech, key); @@ -1353,14 +1357,17 @@ static CK_RV pkcs11_test(int slotId, int setPin, int closeDl) } #endif (void)genericKeyType; + (void)pub; #ifndef NO_AES #ifdef HAVE_AESGCM (void)aes_128_gcm_exp_tag; (void)aes_128_gcm_exp; #endif + #ifndef NO_AES_CBC (void)aes_128_cbc_pad_exp; (void)aes_128_cbc_exp; (void)aes_128_cbc_encrypt_exp; + #endif #ifdef HAVE_AESCTS (void)aes_128_cts_exp; #endif diff --git a/tests/pkcs11test.c b/tests/pkcs11test.c index f37c3c41..a0697126 100644 --- a/tests/pkcs11test.c +++ b/tests/pkcs11test.c @@ -1855,6 +1855,7 @@ static CK_RV test_pkcs5_pbkdf2_key_gen(void* args) ret = CKR_OK; /* Reset for next test */ } +#ifndef NO_AES /* Test with different key types from template */ if (ret == CKR_OK) { CK_KEY_TYPE testAesKeyType = CKK_AES; @@ -1888,7 +1889,9 @@ static CK_RV test_pkcs5_pbkdf2_key_gen(void* args) key = CK_INVALID_HANDLE; } } +#endif +#ifdef WOLFPKCS11_HKDF /* Test with HKDF key type from template */ if (ret == CKR_OK) { CK_KEY_TYPE testHkdfKeyType = CKK_HKDF; @@ -1908,6 +1911,7 @@ static CK_RV test_pkcs5_pbkdf2_key_gen(void* args) key = CK_INVALID_HANDLE; } } +#endif /* Test with NULL salt */ if (ret == CKR_OK) { @@ -16065,6 +16069,7 @@ static CK_RV test_hkdf_derive_implied_class(void* args) } #endif +#ifdef WOLFPKCS11_CONCATENATE static CK_RV concat_create_key(CK_SESSION_HANDLE session, CK_BYTE* value, CK_ULONG len, CK_BBOOL sensitive, CK_BBOOL extractable, CK_BBOOL derive, @@ -16853,6 +16858,77 @@ static CK_RV test_concatenate_logged_out(void* args) return ret; } #endif +#else +static CK_RV test_concatenate_disabled(void* args) +{ + CK_SESSION_HANDLE session = *(CK_SESSION_HANDLE*)args; + CK_RV ret; + CK_MECHANISM_TYPE mechs[3] = { + CKM_CONCATENATE_BASE_AND_KEY, CKM_CONCATENATE_BASE_AND_DATA, + CKM_CONCATENATE_DATA_AND_BASE + }; + CK_MECHANISM_TYPE* list = NULL; + CK_MECHANISM_INFO info; + CK_ULONG count = 0; + CK_ULONG i; + int j; + unsigned char keyData[16] = { 0 }; + unsigned char data[4] = { 0 }; + CK_KEY_DERIVATION_STRING_DATA params = { data, sizeof(data) }; + CK_MECHANISM mech = { CKM_CONCATENATE_BASE_AND_DATA, ¶ms, + sizeof(params) }; + CK_ULONG valueLen = sizeof(keyData) + sizeof(data); + CK_ATTRIBUTE tmpl[] = { + {CKA_CLASS, &secretKeyClass, sizeof(secretKeyClass)}, + {CKA_KEY_TYPE, &genericKeyType, sizeof(genericKeyType)}, + {CKA_VALUE_LEN, &valueLen, sizeof(valueLen)}, + }; + CK_OBJECT_HANDLE hBase = CK_INVALID_HANDLE; + CK_OBJECT_HANDLE hKey = CK_INVALID_HANDLE; + + ret = funcList->C_GetMechanismList(slot, NULL, &count); + CHECK_CKR(ret, "Get Mechanism List count"); + if (ret == CKR_OK) { + list = (CK_MECHANISM_TYPE*)XMALLOC(count * sizeof(CK_MECHANISM_TYPE), + NULL, DYNAMIC_TYPE_TMP_BUFFER); + if (list == NULL) + ret = CKR_DEVICE_MEMORY; + CHECK_CKR(ret, "Allocate mechanism list memory"); + } + if (ret == CKR_OK) { + ret = funcList->C_GetMechanismList(slot, list, &count); + CHECK_CKR(ret, "Get Mechanism List"); + } + for (i = 0; ret == CKR_OK && i < count; i++) { + for (j = 0; j < 3; j++) { + CHECK_COND(list[i] != mechs[j], ret, + "Concatenate mechanism not advertised"); + } + } + for (j = 0; ret == CKR_OK && j < 3; j++) { + ret = funcList->C_GetMechanismInfo(slot, mechs[j], &info); + CHECK_CKR_FAIL(ret, CKR_MECHANISM_INVALID, + "Concatenate mechanism info"); + } + if (ret == CKR_OK) + ret = get_generic_key(session, keyData, sizeof(keyData), CK_TRUE, + &hBase); + if (ret == CKR_OK) { + ret = funcList->C_DeriveKey(session, &mech, hBase, tmpl, + sizeof(tmpl) / sizeof(*tmpl), &hKey); + CHECK_CKR_FAIL(ret, CKR_MECHANISM_INVALID, "Concatenate derive"); + } + + if (hKey != CK_INVALID_HANDLE) + funcList->C_DestroyObject(session, hKey); + if (hBase != CK_INVALID_HANDLE) + funcList->C_DestroyObject(session, hBase); + if (list != NULL) + XFREE(list, NULL, DYNAMIC_TYPE_TMP_BUFFER); + + return ret; +} +#endif /* WOLFPKCS11_CONCATENATE */ #if defined(HAVE_ECC) && !defined(NO_SHA256) static CK_RV stale_key_digest(CK_SESSION_HANDLE session, CK_BBOOL token) @@ -17905,9 +17981,7 @@ static CK_RV test_hkdf_derive_aes_no_value_len(void* args) }; CK_ULONG cnt = sizeof(tmpl) / sizeof(*tmpl); - ret = concat_create_key(session, ikm, sizeof(ikm), CK_FALSE, CK_TRUE, - CK_TRUE, CK_FALSE, &hBase); - CHECK_CKR(ret, "Create HKDF base key"); + ret = get_generic_key(session, ikm, sizeof(ikm), CK_TRUE, &hBase); if (ret == CKR_OK) { ret = funcList->C_DeriveKey(session, &mech, hBase, tmpl, cnt, &hKey); CHECK_CKR_FAIL(ret, CKR_TEMPLATE_INCOMPLETE, @@ -17928,7 +18002,8 @@ static CK_RV test_hkdf_derive_aes_no_value_len(void* args) } #endif -#if defined(WOLFPKCS11_HKDF) && !defined(NO_HMAC) +#if defined(WOLFPKCS11_CONCATENATE) && defined(WOLFPKCS11_HKDF) && \ + !defined(NO_HMAC) static CK_RV test_concatenate_hybrid_hkdf(void* args) { CK_SESSION_HANDLE session = *(CK_SESSION_HANDLE*)args; @@ -21286,6 +21361,7 @@ static TEST_FUNC testFunc[] = { PKCS11TEST_FUNC_SESS_DECL(test_hkdf_derive_expand_null_value_len), PKCS11TEST_FUNC_SESS_DECL(test_hkdf_derive_implied_class), #endif +#ifdef WOLFPKCS11_CONCATENATE PKCS11TEST_FUNC_SESS_DECL(test_concatenate_base_and_key), PKCS11TEST_FUNC_SESS_DECL(test_concatenate_data), PKCS11TEST_FUNC_SESS_DECL(test_concatenate_protection), @@ -21294,6 +21370,9 @@ static TEST_FUNC testFunc[] = { #ifndef WOLFPKCS11_NO_STORE PKCS11TEST_FUNC_SESS_DECL(test_concatenate_logged_out), #endif +#else + PKCS11TEST_FUNC_SESS_DECL(test_concatenate_disabled), +#endif #ifndef WOLFPKCS11_NO_STORE PKCS11TEST_FUNC_SESS_DECL(test_key_use_logged_out), #endif @@ -21312,7 +21391,8 @@ static TEST_FUNC testFunc[] = { !defined(WOLFPKCS11_NSS) PKCS11TEST_FUNC_SESS_DECL(test_hkdf_derive_aes_no_value_len), #endif -#if defined(WOLFPKCS11_HKDF) && !defined(NO_HMAC) +#if defined(WOLFPKCS11_CONCATENATE) && defined(WOLFPKCS11_HKDF) && \ + !defined(NO_HMAC) PKCS11TEST_FUNC_SESS_DECL(test_concatenate_hybrid_hkdf), #endif #ifdef WOLFSSL_HAVE_PRF @@ -21353,10 +21433,10 @@ static TEST_FUNC testFunc[] = { PKCS11TEST_FUNC_SESS_DECL(test_nss_pkcs12_pbe_key_sizes), #endif #endif +#endif #ifndef NO_HMAC PKCS11TEST_FUNC_SESS_DECL(test_pkcs5_pbkdf2_key_gen), #endif -#endif #ifndef NO_SHA PKCS11TEST_FUNC_SESS_DECL(test_x509_check_value), #endif diff --git a/tests/pkcs11v3test.c b/tests/pkcs11v3test.c index aa86b541..49e69903 100644 --- a/tests/pkcs11v3test.c +++ b/tests/pkcs11v3test.c @@ -2424,7 +2424,8 @@ static CK_RV test_copy_object_mlkem_key(void* args) return ret; } -#if defined(HAVE_ECC) && defined(WOLFPKCS11_HKDF) && !defined(NO_HMAC) +#if defined(WOLFPKCS11_CONCATENATE) && defined(HAVE_ECC) && \ + defined(WOLFPKCS11_HKDF) && !defined(NO_HMAC) static CK_OBJECT_CLASS hybridSecretClass = CKO_SECRET_KEY; static CK_KEY_TYPE hybridGenericType = CKK_GENERIC_SECRET; static CK_BBOOL hybridFalse = CK_FALSE; @@ -4416,7 +4417,8 @@ static TEST_FUNC testFunc[] = { PKCS11TEST_FUNC_SESS_DECL(test_mlkem_initial_states), PKCS11TEST_FUNC_SESS_DECL(test_mlkem_encap_decap_not_permitted), PKCS11TEST_FUNC_SESS_DECL(test_copy_object_mlkem_key), -#if defined(HAVE_ECC) && defined(WOLFPKCS11_HKDF) && !defined(NO_HMAC) +#if defined(WOLFPKCS11_CONCATENATE) && defined(HAVE_ECC) && \ + defined(WOLFPKCS11_HKDF) && !defined(NO_HMAC) PKCS11TEST_FUNC_SESS_DECL(test_concatenate_hybrid_agreement), #endif #ifndef WOLFPKCS11_NO_STORE diff --git a/wolfpkcs11/internal.h b/wolfpkcs11/internal.h index 44ac67a2..5f831524 100644 --- a/wolfpkcs11/internal.h +++ b/wolfpkcs11/internal.h @@ -349,17 +349,22 @@ C_EXTRA_FLAGS="-DWOLFSSL_PUBLIC_MP -DWC_RSA_DIRECT" #endif /* Maximum size of storage for generated/derived symmetric key. */ +#ifndef WP11_MAX_SYM_KEY_SZ #ifdef WOLFPKCS11_NSS #define WP11_MAX_SYM_KEY_SZ (2048) #elif !defined(NO_DH) #define WP11_MAX_SYM_KEY_SZ (4096/8) -#elif defined(WOLFPKCS11_MLKEM) +#elif defined(WOLFPKCS11_CONCATENATE) #define WP11_MAX_SYM_KEY_SZ 256 #elif defined(HAVE_ECC) #define WP11_MAX_SYM_KEY_SZ ((521+7)/8) #else #define WP11_MAX_SYM_KEY_SZ 64 #endif +#endif +#if !defined(NO_AES) && WP11_MAX_SYM_KEY_SZ < 32 +#error "WP11_MAX_SYM_KEY_SZ must hold an AES-256 key" +#endif /* Maximum size of storage for generated/derived DH key. */ #ifdef WOLFPKCS11_NSS @@ -724,10 +729,12 @@ WP11_LOCAL int WP11_GenerateRandomKey(WP11_Object* secret, WP11_Slot* slot, WP11_LOCAL int WP11_KDF_Derive(WP11_Session* session, CK_HKDF_PARAMS_PTR params, unsigned char* key, word32* keyLen, WP11_Object* priv); +#ifdef WOLFPKCS11_CONCATENATE WP11_LOCAL int WP11_Concat_KeyLen(WP11_Object* key, word32* len); WP11_LOCAL int WP11_Concat_Derive(WP11_Object* base, WP11_Object* other, const byte* data, word32 dataLen, int dataFirst, byte* out, word32 outLen); +#endif WP11_LOCAL int WP11_Tls12_Master_Key_Derive(CK_SSL3_RANDOM_DATA* random, CK_MECHANISM_TYPE mech, const char* label,