diff --git a/examples/include.am b/examples/include.am index 34035d9f..1d67dc3f 100644 --- a/examples/include.am +++ b/examples/include.am @@ -47,6 +47,7 @@ examples_token_info_LDADD = dist_noinst_SCRIPTS += examples/examples.test EXTRA_DIST += examples/rsa-2048.der +EXTRA_DIST += examples/stm32_dhuk_aes_key.c if BUILD_STATIC examples_add_aes_key_LDADD += src/libwolfpkcs11.la diff --git a/examples/stm32_dhuk_aes_key.c b/examples/stm32_dhuk_aes_key.c new file mode 100644 index 00000000..dd749e0c --- /dev/null +++ b/examples/stm32_dhuk_aes_key.c @@ -0,0 +1,477 @@ +/* stm32_dhuk_aes_key.c + * + * Copyright (C) 2006-2025 wolfSSL Inc. + * + * This file is part of wolfPKCS11. + * + * wolfPKCS11 is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * wolfPKCS11 is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335, USA + */ + + +#ifdef HAVE_CONFIG_H + #include +#endif + +#ifndef WOLFSSL_USER_SETTINGS + #include +#endif +#include +#include +#include + +#ifndef WOLFPKCS11_USER_SETTINGS + #include +#endif +#include + +extern int uart_printf(const char* format, ...); +#undef printf +#define printf uart_printf + +#ifdef DEBUG_WOLFPKCS11 + #define CHECK_CKR(rv, op) \ + fprintf(stderr, "%s: %ld\n", op, rv) +#else + #define CHECK_CKR(rv, op) \ + if (ret != CKR_OK) \ + printf("%s: %ld\n", op, rv) +#endif + + +/* DLL Location and slot */ +#ifndef WOLFPKCS11_DLL_FILENAME + #ifdef __MACH__ + #define WOLFPKCS11_DLL_FILENAME "./src/.libs/libwolfpkcs11.dylib" + #else + #define WOLFPKCS11_DLL_FILENAME "./src/.libs/libwolfpkcs11.so" + #endif +#endif +#ifndef WOLFPKCS11_DLL_SLOT + #define WOLFPKCS11_DLL_SLOT 1 +#endif + +static CK_FUNCTION_LIST* funcList; +static CK_SLOT_ID slot = WOLFPKCS11_DLL_SLOT; + +static byte* userPin = (byte*)"wolfpkcs11-test"; +static CK_ULONG userPinLen; + + +static CK_RV pkcs11_init(CK_SESSION_HANDLE* session) +{ + CK_RV ret = CKR_OK; + + ret = C_GetFunctionList(&funcList); + + if (ret == CKR_OK) { + ret = funcList->C_Initialize(NULL); + CHECK_CKR(ret, "Initialize"); + } + + if (ret == CKR_OK) { + CK_FLAGS sessFlags = CKF_SERIAL_SESSION | CKF_RW_SESSION; + + ret = funcList->C_OpenSession(slot, sessFlags, NULL, NULL, session); + CHECK_CKR(ret, "Open Session"); + if (ret == CKR_OK && userPinLen != 0) { + ret = funcList->C_Login(*session, CKU_USER, userPin, userPinLen); + CHECK_CKR(ret, "Login"); + } + } + + return ret; +} + + +static void pkcs11_final(CK_SESSION_HANDLE session) +{ + if (userPinLen != 0) + funcList->C_Logout(session); + funcList->C_CloseSession(session); + + funcList->C_Finalize(NULL); +} + + +static CK_OBJECT_CLASS secretKeyClass = CKO_SECRET_KEY; +static CK_BBOOL ckTrue = CK_TRUE; +#ifndef NO_AES +static CK_KEY_TYPE aesKeyType = CKK_AES; +#else +static CK_KEY_TYPE genericKeyType = CKK_GENERIC_SECRET; +#endif + +static unsigned char aes256Key[] = { + 0x60,0x3d,0xeb,0x10,0x15,0xca,0x71,0xbe, + 0x2b,0x73,0xae,0xf0,0x85,0x7d,0x77,0x81, + 0x1f,0x35,0x2c,0x07,0x3b,0x61,0x08,0xd7, + 0x2d,0x98,0x10,0xa3,0x09,0x14,0xdf,0xf4 + }; + + +CK_RV pkcs11_add_aes_dhuk_key(CK_SESSION_HANDLE session); +CK_RV pkcs11_add_aes_dhuk_key(CK_SESSION_HANDLE session) +{ + CK_RV ret; + CK_ULONG devId = WOLFSSL_STM32U5_DHUK_DEVID;/* signal use of hardware key */ + CK_ATTRIBUTE aes_dhuk_secret_key[] = { + { CKA_CLASS, &secretKeyClass, sizeof(secretKeyClass) }, +#ifndef NO_AES + { CKA_KEY_TYPE, &aesKeyType, sizeof(aesKeyType) }, +#else + { CKA_KEY_TYPE, &genericKeyType, sizeof(genericKeyType) }, +#endif + { CKA_WRAP, &ckTrue, sizeof(ckTrue) }, + { CKA_UNWRAP, &ckTrue, sizeof(ckTrue) }, + { CKA_TOKEN, &ckTrue, sizeof(ckTrue) }, + { CKA_VALUE, aes256Key, sizeof(aes256Key) }, + { CKA_WOLFSSL_DEVID, &devId, sizeof(devId) }, + }; + CK_ULONG cnt = sizeof(aes_dhuk_secret_key)/sizeof(*aes_dhuk_secret_key); + CK_OBJECT_HANDLE obj; + + ret = funcList->C_CreateObject(session, aes_dhuk_secret_key, cnt, &obj); + CHECK_CKR(ret, "CreateObject AES DHUK key"); + + return ret; +} + +CK_RV pkcs11_add_aes_software_key(CK_SESSION_HANDLE session); +CK_RV pkcs11_add_aes_software_key(CK_SESSION_HANDLE session) +{ + CK_RV ret; + CK_ULONG devId = WOLFSSL_STM32U5_SAES_DEVID; + CK_ATTRIBUTE aes256SecretKey[] = { + { CKA_CLASS, &secretKeyClass, sizeof(secretKeyClass) }, +#ifndef NO_AES + { CKA_KEY_TYPE, &aesKeyType, sizeof(aesKeyType) }, +#else + { CKA_KEY_TYPE, &genericKeyType, sizeof(genericKeyType) }, +#endif + { CKA_ENCRYPT, &ckTrue, sizeof(ckTrue) }, + { CKA_DECRYPT, &ckTrue, sizeof(ckTrue) }, + { CKA_TOKEN, &ckTrue, sizeof(ckTrue) }, + { CKA_VALUE, aes256Key, sizeof(aes256Key) }, + { CKA_WOLFSSL_DEVID, &devId, sizeof(devId) }, + }; + CK_ULONG cnt = sizeof(aes256SecretKey)/sizeof(*aes256SecretKey); + CK_OBJECT_HANDLE obj; + + ret = funcList->C_CreateObject(session, aes256SecretKey, cnt, &obj); + CHECK_CKR(ret, "CreateObject AES 256-bit key"); + + return ret; +} + +CK_OBJECT_HANDLE find_key_type(CK_SESSION_HANDLE session, int devId); +CK_OBJECT_HANDLE find_key_type(CK_SESSION_HANDLE session, int devId) +{ + CK_RV ret = CKR_OK; + CK_OBJECT_HANDLE obj, match = 0; + CK_ATTRIBUTE findTmpl; + CK_ULONG cnt; + + /* Find all objects. */ + ret = funcList->C_FindObjectsInit(session, &findTmpl, 0); + CHECK_CKR(ret, "Initialize Find"); + + while (ret == CKR_OK) { + CK_ULONG devIdFound; + CK_ULONG devIdLen = sizeof(devIdFound); + CK_ATTRIBUTE getTmpl[] = { + { CKA_WOLFSSL_DEVID, &devIdFound, devIdLen }, + }; + CK_ULONG getTmplCnt = sizeof(getTmpl) / sizeof(CK_ATTRIBUTE); + + ret = funcList->C_FindObjects(session, &obj, 1, &cnt); + CHECK_CKR(ret, "Find Object"); + if (cnt == 1) { + /* check devId match */ + ret = funcList->C_GetAttributeValue(session, obj, getTmpl, + getTmplCnt); + printf("Return value from GetAttributeValue = %d, {%d, %d}\n", + ret, devIdFound, getTmpl[0].ulValueLen); + if ((int)devIdFound == devId) { + match = obj; + break; + } + } + else { + break; + } + } + ret = funcList->C_FindObjectsFinal(session); + CHECK_CKR(ret, "Find Object Final"); + + return match; +} + +CK_OBJECT_HANDLE find_dhuk_key(CK_SESSION_HANDLE session); +CK_OBJECT_HANDLE find_dhuk_key(CK_SESSION_HANDLE session) +{ + CK_OBJECT_HANDLE ret; + ret = find_key_type(session, WOLFSSL_STM32U5_DHUK_DEVID); + if (ret == 0) { + printf("Failed to find DHUK key\n"); + } + else { + printf("Found DHUK key\n"); + } + return ret; +} + +static CK_OBJECT_HANDLE find_software_key(CK_SESSION_HANDLE session) +{ + CK_OBJECT_HANDLE ret; + ret = find_key_type(session, WOLFSSL_STM32U5_SAES_DEVID); + if (ret == 0) { + printf("Failed to find software key\n"); + } + else { + printf("Found software key\n"); + } + return ret; +} + +static CK_OBJECT_HANDLE find_wrapped_key(CK_SESSION_HANDLE session) +{ + CK_OBJECT_HANDLE ret; + ret = find_key_type(session, WOLFSSL_STM32U5_DHUK_WRAPPED_DEVID); + if (ret == 0) { + printf("Failed to find wrapped key\n"); + } + else { + printf("Found wrapped key\n"); + } + return ret; +} + + +CK_RV pkcs11_wrap_aes_key(CK_SESSION_HANDLE session); +CK_RV pkcs11_wrap_aes_key(CK_SESSION_HANDLE session) +{ + CK_OBJECT_HANDLE wrappedKey; + CK_OBJECT_HANDLE dhuk; + CK_OBJECT_HANDLE key; + CK_BYTE wrappedKeyBuffer[32]; + CK_ULONG wrappedKeyBufferLen = sizeof(wrappedKeyBuffer); + CK_ULONG devId = WOLFSSL_STM32U5_DHUK_WRAPPED_DEVID; + CK_MECHANISM mech = {CKM_AES_ECB, NULL, 0}; + int i; + CK_RV rv; + CK_ATTRIBUTE wrappedKeyTemplate[] = { + { CKA_CLASS, &secretKeyClass, sizeof(secretKeyClass) }, + { CKA_KEY_TYPE, &aesKeyType, sizeof(aesKeyType) }, + { CKA_VALUE, wrappedKeyBuffer, wrappedKeyBufferLen }, + { CKA_ENCRYPT, &ckTrue, sizeof(ckTrue) }, + { CKA_DECRYPT, &ckTrue, sizeof(ckTrue) }, + { CKA_TOKEN, &ckTrue, sizeof(ckTrue) }, + { CKA_WOLFSSL_DEVID, &devId, sizeof(devId) }, + }; + CK_ULONG wrappedKeyTemplateLen = sizeof(wrappedKeyTemplate) / + sizeof(CK_ATTRIBUTE); + + + key = find_software_key(session); + if (key == 0) { + return CKR_FUNCTION_FAILED; + } + + /* Wrap the key using the DHUK key */ + dhuk = find_dhuk_key(session); + if (dhuk == 0) { + return CKR_FUNCTION_FAILED; + } + + /* Perform the wrapping operation */ + rv = funcList->C_WrapKey(session, &mech, dhuk, key, wrappedKeyBuffer, + &wrappedKeyBufferLen); + if (rv != CKR_OK) { + printf("Failed to wrap key, ret = %d\n", rv); + return rv; + } + + printf("DHUK wrapped key created : "); + for (i = 0; i < wrappedKeyBufferLen; i++) { + printf("%02X", wrappedKeyBuffer[i]); + } + printf("\n"); + + /* Create a wrapped key object */ + rv = funcList->C_CreateObject(session, wrappedKeyTemplate, + wrappedKeyTemplateLen, &wrappedKey); + if (rv != CKR_OK) { + return rv; + } + + printf("Created a key wrapped with using the DHUK\n"); + + return CKR_OK; +} + + +static CK_RV pkcs11_encrypt_with_key(CK_SESSION_HANDLE session, + CK_OBJECT_HANDLE key, byte* data, CK_ULONG dataLen, byte* iv, byte* out, + CK_ULONG_PTR outLen) +{ + CK_MECHANISM mech = {CKM_AES_CBC, iv, 16}; + /* CK_MECHANISM mech = {CKM_AES_ECB, NULL, 0}; */ + CK_RV rv; + + rv = funcList->C_EncryptInit(session, &mech, key); + if (rv != CKR_OK) { + return rv; + } + + rv = funcList->C_Encrypt(session, data, dataLen, out, outLen); + if (rv != CKR_OK) { + return rv; + } + + return CKR_OK; +} + + +static CK_RV pkcs11_decrypt_with_key(CK_SESSION_HANDLE session, + CK_OBJECT_HANDLE key, byte* data, CK_ULONG dataLen, byte* iv, byte* out, + CK_ULONG_PTR outLen) +{ + CK_MECHANISM mech = {CKM_AES_CBC, iv, 16}; + /* CK_MECHANISM mech = {CKM_AES_ECB, NULL, 0}; */ + CK_RV rv; + + rv = funcList->C_DecryptInit(session, &mech, key); + if (rv != CKR_OK) { + return rv; + } + + rv = funcList->C_Decrypt(session, data, dataLen, out, outLen); + if (rv != CKR_OK) { + return rv; + } + + return CKR_OK; +} + + +/* compare encryption using the wrapped AES key versus unwrapped one */ +static CK_RV pkcs11_compare_results(CK_SESSION_HANDLE session) +{ + CK_RV ret = 0; + byte plain[] = { + 0x6b,0xc1,0xbe,0xe2,0x2e,0x40,0x9f,0x96, + 0xe9,0x3d,0x7e,0x11,0x73,0x93,0x17,0x2a + }; + byte cipher[16]; + byte output[16]; + byte iv[16]; + CK_ULONG cipherLen = sizeof(cipher); + CK_ULONG outputLen = sizeof(output); + CK_OBJECT_HANDLE key; + int i; + + printf("Software key and wrapped key should produce the same results\n"); + + /* in applications a random IV should be used */ + for (i = 0; i < 16; i++) { + iv[i] = i; + } + + /* Encrypt plain text using software only key */ + key = find_software_key(session); + memset(cipher, 0, sizeof(cipher)); + ret = pkcs11_encrypt_with_key(session, key, plain, sizeof(plain), iv, + cipher, &cipherLen); + if (ret != CKR_OK) { + return ret; + } + + printf("\tSAES User Key [Encrypted]: "); + for (i = 0; i < cipherLen; i++) { + printf("%02X", cipher[i]); + } + printf("\n"); + + /* encrypt using wrapped key */ + memset(cipher, 0, sizeof(cipher)); + key = find_wrapped_key(session); + ret = pkcs11_encrypt_with_key(session, key, plain, sizeof(plain), iv, + cipher, &cipherLen); + if (ret != CKR_OK) { + return ret; + } + + printf("\tWrapped Key [Encrypted] : "); + for (i = 0; i < cipherLen; i++) { + printf("%02X", cipher[i]); + } + printf("\n"); + + memset(output, 0, sizeof(output)); + ret = pkcs11_decrypt_with_key(session, key, cipher, cipherLen, iv, output, + &outputLen); + if (ret != CKR_OK) { + return ret; + } + + printf("\tWrapped Key [Decrypted] : "); + for (i = 0; i < outputLen; i++) { + printf("%02X", output[i]); + } + printf("\n"); + + return ret; +} + + +#ifndef NO_MAIN_DRIVER +int main(int argc, char* argv[]) +#else +int stm32_dhuk_aes_key(int argc, char* argv[]) +#endif +{ + int ret; + CK_RV rv; + CK_SESSION_HANDLE session = CK_INVALID_HANDLE; + +#ifndef WOLFPKCS11_NO_ENV + if (!XGETENV("WOLFPKCS11_TOKEN_PATH")) { + XSETENV("WOLFPKCS11_TOKEN_PATH", "./store", 1); + } +#endif + printf("Example PKCS11 DHUK AES use\n\r"); + + + rv = pkcs11_init(&session); + if (rv == CKR_OK) { + rv = pkcs11_add_aes_dhuk_key(session); + } + if (rv == CKR_OK) { + rv = pkcs11_add_aes_software_key(session); + } + if (rv == CKR_OK) { + rv = pkcs11_wrap_aes_key(session); + } + if (rv == CKR_OK) { + rv = pkcs11_compare_results(session); + } + pkcs11_final(session); + + if (rv == CKR_OK) + ret = 0; + else + ret = 1; + return ret; +} diff --git a/src/crypto.c b/src/crypto.c index 7e4ee71e..1c131d1b 100644 --- a/src/crypto.c +++ b/src/crypto.c @@ -235,6 +235,7 @@ static AttributeType attrType[] = { { CKA_TRUST_CODE_SIGNING, ATTR_TYPE_ULONG }, { CKA_TRUST_STEP_UP_APPROVED, ATTR_TYPE_BOOL }, #endif + { CKA_WOLFSSL_DEVID, ATTR_TYPE_ULONG }, }; /* Count of elements in attribute type list. */ #define ATTR_TYPE_SIZE (sizeof(attrType) / sizeof(*attrType)) @@ -6627,12 +6628,12 @@ CK_RV C_WrapKey(CK_SESSION_HANDLE hSession, keyClass = WP11_Object_GetClass(key); rv = CHECK_WRAPPABLE(keyClass, keyType); - if (rv != CKR_OK) + if (rv != CKR_OK) { return rv; + } switch (keyType) { -#ifndef WOLFPKCS11_NO_STORE -#ifndef NO_RSA +#if !defined(NO_RSA) && !defined(WOLFPKCS11_NO_STORE) case CKK_RSA: ret = WP11_Rsa_SerializeKeyPTPKC8(key, NULL, &serialSize); if (ret != 0) @@ -6650,6 +6651,7 @@ CK_RV C_WrapKey(CK_SESSION_HANDLE hSession, } break; #endif +#if defined(WOLFSSL_STM32U5_DHUK) || !defined(WOLFPKCS11_NO_STORE) #ifndef NO_AES case CKK_AES: #endif @@ -6692,14 +6694,27 @@ CK_RV C_WrapKey(CK_SESSION_HANDLE hSession, goto err_out; } - rv = EncryptInit(hSession, pMechanism, hWrappingKey, 1); - if (rv != CKR_OK) - goto err_out; - - rv = C_Encrypt(hSession, serialBuff, serialSize, pWrappedKey, pulWrappedKeyLen); - if (rv != CKR_OK) - goto err_out; + #ifdef WOLFPKCS11_DHUK + if (WP11_Object_GetDevId(wrappingKey) == + WOLFSSL_STM32U5_DHUK_DEVID) { + if (wc_Stm32_Aes_Wrap(NULL, serialBuff, serialSize, pWrappedKey, + (word32*)pulWrappedKeyLen, NULL) != 0) { + rv = CKR_FUNCTION_FAILED; + goto err_out; + } + } + else + #endif + { + rv = EncryptInit(hSession, pMechanism, hWrappingKey, 1); + if (rv != CKR_OK) + goto err_out; + rv = C_Encrypt(hSession, serialBuff, serialSize, pWrappedKey, + pulWrappedKeyLen); + if (rv != CKR_OK) + goto err_out; + } break; #endif #ifndef NO_RSA diff --git a/src/internal.c b/src/internal.c index 4fb5372f..f51043aa 100644 --- a/src/internal.c +++ b/src/internal.c @@ -43,6 +43,7 @@ #include #include +#if !defined(WOLFPKCS11_NO_STORE) && !defined(WOLFPKCS11_CUSTOM_STORE) /* OS-specific includes for directory creation */ #if defined(_WIN32) || defined(_MSC_VER) #include @@ -53,6 +54,7 @@ #include #define MKDIR(path) mkdir(path, 0700) #endif +#endif #include #include @@ -292,6 +294,7 @@ struct WP11_Object { WP11_Lock* lock; /* Object specific lock */ + int devId; WP11_Object* next; /* Next object in linked list */ }; @@ -811,6 +814,7 @@ int WP11_Slot_SOPin_IsSet(WP11_Slot* slot) return slot->token.tokenFlags & WP11_TOKEN_FLAG_SO_PIN_SET; } + /** * Add a new session to the token in the slot. * @@ -2078,6 +2082,7 @@ static int wp11_Object_New(WP11_Slot* slot, CK_KEY_TYPE type, obj->onToken = 0; obj->slot = slot; obj->keyGenMech = CK_UNAVAILABLE_INFORMATION; + obj->devId = slot->devId; /* default to slot's devId */ /* TPM key allocation will be done later when object class is known */ } @@ -2315,6 +2320,7 @@ int WP11_Object_Copy(WP11_Object *src, WP11_Object *dest) OBJ_COPY_DATA(src, dest, subject); dest->category = src->category; + dest->devId = src->devId; if (src->objClass == CKO_CERTIFICATE) { return BAD_FUNC_ARG; @@ -2339,13 +2345,13 @@ int WP11_Object_Copy(WP11_Object *src, WP11_Object *dest) #ifndef NO_RSA case CKK_RSA: ret = wc_InitRsaKey_ex(dest->data.rsaKey, NULL, - dest->slot->devId); + dest->devId); break; #endif #ifdef HAVE_ECC case CKK_EC: ret = wc_ecc_init_ex(dest->data.ecKey, NULL, - dest->slot->devId); + dest->devId); break; #endif default: @@ -2386,7 +2392,7 @@ int WP11_Object_Copy(WP11_Object *src, WP11_Object *dest) /* Initialize destination RSA key */ ret = wc_InitRsaKey_ex(dest->data.rsaKey, NULL, - dest->slot->devId); + dest->devId); if (ret != 0) break; @@ -2452,7 +2458,7 @@ int WP11_Object_Copy(WP11_Object *src, WP11_Object *dest) /* Initialize destination ECC key */ ret = wc_ecc_init_ex(dest->data.ecKey, NULL, - dest->slot->devId); + dest->devId); if (ret != 0) break; @@ -2561,12 +2567,12 @@ int WP11_Object_Copy(WP11_Object *src, WP11_Object *dest) * @return -ve on failure. */ static int wp11_EncryptData(byte* out, byte* data, int len, byte* key, - int keySz, byte* iv, int ivSz) + int keySz, byte* iv, int ivSz, int devId) { Aes aes; int ret; - ret = wc_AesInit(&aes, NULL, INVALID_DEVID); + ret = wc_AesInit(&aes, NULL, devId); if (ret == 0) { ret = wc_AesGcmSetKey(&aes, key, keySz); } @@ -2595,12 +2601,12 @@ static int wp11_EncryptData(byte* out, byte* data, int len, byte* key, * @return Other -ve on failure. */ static int wp11_DecryptData(byte* out, byte* data, int len, byte* key, - int keySz, byte* iv, int ivSz) + int keySz, byte* iv, int ivSz, int devId) { Aes aes; int ret; - ret = wc_AesInit(&aes, NULL, INVALID_DEVID); + ret = wc_AesInit(&aes, NULL, devId); if (ret == 0) { ret = wc_AesGcmSetKey(&aes, key, keySz); } @@ -3282,7 +3288,7 @@ static int wp11_Object_Decode_RsaKey(WP11_Object* object) word32 idx = 0; RsaKey* key = object->data.rsaKey; - ret = wc_InitRsaKey_ex(key, NULL, object->slot->devId); + ret = wc_InitRsaKey_ex(key, NULL, object->devId); if (ret != 0) { return ret; } @@ -3305,7 +3311,7 @@ static int wp11_Object_Decode_RsaKey(WP11_Object* object) ret = wp11_DecryptData(der, object->keyData, len, object->slot->token.key, sizeof(object->slot->token.key), object->iv, - sizeof(object->iv)); + sizeof(object->iv), object->devId); } if (ret == 0) { /* Decode RSA private key. */ @@ -3397,7 +3403,7 @@ static int wp11_Object_Encode_RsaKey(WP11_Object* object) ret = wp11_EncryptData(object->keyData, object->keyData, ret, object->slot->token.key, sizeof(object->slot->token.key), object->iv, - sizeof(object->iv)); + sizeof(object->iv), object->devId); } #else ret = NOT_COMPILED_IN; @@ -3628,7 +3634,7 @@ static int wp11_Object_Decode_EccKey(WP11_Object* object) word32 idx = 0; ecc_key* key = object->data.ecKey; - ret = wc_ecc_init_ex(key, NULL, object->slot->devId); + ret = wc_ecc_init_ex(key, NULL, object->devId); if (ret != 0) { return ret; } @@ -3651,10 +3657,10 @@ static int wp11_Object_Decode_EccKey(WP11_Object* object) ret = wp11_DecryptData(der, object->keyData, len, object->slot->token.key, sizeof(object->slot->token.key), object->iv, - sizeof(object->iv)); + sizeof(object->iv), object->devId); } if (ret == 0) { - ret = wc_ecc_init_ex(key, NULL, object->slot->devId); + ret = wc_ecc_init_ex(key, NULL, object->devId); } if (ret == 0) { /* Decode ECC private key. */ @@ -3736,7 +3742,7 @@ static int wp11_Object_Encode_EccKey(WP11_Object* object) ret = wp11_EncryptData(object->keyData, object->keyData, ret, object->slot->token.key, sizeof(object->slot->token.key), object->iv, - sizeof(object->iv)); + sizeof(object->iv), object->devId); } } else if (ret == 0 && object->objClass == CKO_PUBLIC_KEY) { @@ -3856,7 +3862,7 @@ static int wp11_Object_Decode_DhKey(WP11_Object* object) object->keyDataLen - AES_BLOCK_SIZE, object->slot->token.key, sizeof(object->slot->token.key), object->iv, - sizeof(object->iv)); + sizeof(object->iv), object->devId); if (ret == 0) object->data.dhKey->len = object->keyDataLen - AES_BLOCK_SIZE; } @@ -3896,7 +3902,7 @@ static int wp11_Object_Encode_DhKey(WP11_Object* object) object->data.dhKey->len, object->slot->token.key, sizeof(object->slot->token.key), object->iv, - sizeof(object->iv)); + sizeof(object->iv), object->devId); if (ret == 0) object->keyDataLen = object->data.dhKey->len + AES_BLOCK_SIZE; } @@ -4190,7 +4196,7 @@ static int wp11_Object_Decode_SymmKey(WP11_Object* object) object->keyDataLen - AES_BLOCK_SIZE, object->slot->token.key, sizeof(object->slot->token.key), object->iv, - sizeof(object->iv)); + sizeof(object->iv), object->devId); } if (ret == 0) object->data.symmKey->len = object->keyDataLen - AES_BLOCK_SIZE; @@ -4223,7 +4229,7 @@ static int wp11_Object_Encode_SymmKey(WP11_Object* object) object->data.symmKey->len, object->slot->token.key, sizeof(object->slot->token.key), object->iv, - sizeof(object->iv)); + sizeof(object->iv), object->devId); if (ret == 0) object->keyDataLen = object->data.symmKey->len + AES_BLOCK_SIZE; } @@ -4850,6 +4856,7 @@ static int wp11_Object_Unstore(WP11_Object* object, int tokenId, int objId) } #endif /* !WOLFPKCS11_NO_STORE */ + /** * Initialize the token. * @@ -5348,6 +5355,8 @@ static int wp11_Slot_Init(WP11_Slot* slot, int id) ret = wp11_TpmInit(slot); #elif defined (WOLFSSL_MAXQ10XX_CRYPTO) slot->devId = MAXQ_DEVICE_ID; + #elif defined (WOLFSSL_STM32U5_DHUK) + slot->devId = WOLFSSL_STM32U5_SAES_DEVID; #endif /* Create the minimum number of unused sessions. */ for (i = 0; ret == 0 && i < WP11_SESSION_CNT_MIN; i++) { @@ -6803,7 +6812,7 @@ int WP11_Session_SetCbcParams(WP11_Session* session, unsigned char* iv, WP11_Data* key; /* AES object on session. */ - ret = wc_AesInit(&cbc->aes, NULL, session->devId); + ret = wc_AesInit(&cbc->aes, NULL, object->devId); if (ret == 0) { if (object->onToken) WP11_Lock_LockRO(object->lock); @@ -6841,7 +6850,7 @@ int WP11_Session_SetCtrParams(WP11_Session* session, CK_ULONG ulCounterBits, if (ulCounterBits > 128 || ulCounterBits == 0) return BAD_FUNC_ARG; - ret = wc_AesInit(&ctr->aes, NULL, session->devId); + ret = wc_AesInit(&ctr->aes, NULL, object->devId); if (ret == 0) { if (object->onToken) WP11_Lock_LockRO(object->lock); @@ -6864,7 +6873,7 @@ int WP11_Session_SetAesWrapParams(WP11_Session* session, byte* iv, word32 ivLen, WP11_Data *key; XMEMSET(wrap, 0, sizeof(*wrap)); - ret = wc_AesInit(&wrap->aes, NULL, session->devId); + ret = wc_AesInit(&wrap->aes, NULL, object->devId); if (ret == 0) { if (object->onToken) WP11_Lock_LockRO(object->lock); @@ -6988,7 +6997,7 @@ int WP11_Session_SetCtsParams(WP11_Session* session, unsigned char* iv, WP11_Data* key; /* AES object on session. */ - ret = wc_AesInit(&cts->aes, NULL, session->devId); + ret = wc_AesInit(&cts->aes, NULL, object->devId); if (ret == 0) { if (object->onToken) WP11_Lock_LockRO(object->lock); @@ -7152,6 +7161,7 @@ int WP11_Session_RemoveObject(WP11_Session* session, WP11_Object* object) else { WP11_Lock_UnlockRW(&session->slot->token.lock); } + (void)id; /* set but not used with WOLFPKCS11_NO_STORE */ return ret; } @@ -7454,6 +7464,17 @@ CK_KEY_TYPE WP11_Object_GetType(WP11_Object* object) return object->type; } +/** + * Get the object's devId. + * + * @param object [in] Object object. + * @return Object's devId. + */ +CK_ULONG WP11_Object_GetDevId(WP11_Object* object) +{ + return (CK_ULONG)object->devId; +} + /** * Get the object's class. * @@ -7510,7 +7531,7 @@ int WP11_Object_SetRsaKey(WP11_Object* object, unsigned char** data, WP11_Lock_LockRW(object->lock); key = object->data.rsaKey; - ret = wc_InitRsaKey_ex(key, NULL, object->slot->devId); + ret = wc_InitRsaKey_ex(key, NULL, object->devId); if (ret == 0) { ret = SetMPI(&key->d, data[1], (int)len[1]); if (ret == 0) @@ -7695,7 +7716,7 @@ int WP11_Object_SetEcKey(WP11_Object* object, unsigned char** data, WP11_Lock_LockRW(object->lock); key = object->data.ecKey; - ret = wc_ecc_init_ex(key, NULL, object->slot->devId); + ret = wc_ecc_init_ex(key, NULL, object->devId); if (ret == 0) { if (ret == 0 && data[0] != NULL) ret = EcSetParams(key, data[0], (int)len[0]); @@ -7754,7 +7775,7 @@ int WP11_Object_SetDhKey(WP11_Object* object, unsigned char** data, WP11_Lock_LockRW(object->lock); key = object->data.dhKey; - ret = wc_InitDhKey_ex(&key->params, NULL, INVALID_DEVID); + ret = wc_InitDhKey_ex(&key->params, NULL, object->devId); if (ret == 0) { if (data[0] != NULL && data[1] != NULL) ret = wc_DhSetKey(&key->params, data[0], (int)len[0], data[1], @@ -8174,6 +8195,7 @@ static int GetULong(CK_ULONG value, byte* data, CK_ULONG* len) return ret; } + /** * Get the data of a data array. * @@ -8945,6 +8967,10 @@ int WP11_Object_GetAttr(WP11_Object* object, CK_ATTRIBUTE_TYPE type, byte* data, } break; } + + case CKA_WOLFSSL_DEVID: + ret = GetULong(object->devId, data, len); + break; } if (object->onToken) @@ -9316,6 +9342,11 @@ int WP11_Object_SetAttr(WP11_Object* object, CK_ATTRIBUTE_TYPE type, byte* data, ret = BAD_FUNC_ARG; } break; + + case CKA_WOLFSSL_DEVID: + object->devId = (int)(*(CK_ULONG*)data); + break; + default: ret = BAD_FUNC_ARG; break; @@ -9568,7 +9599,7 @@ int WP11_Rsa_ParsePrivKey(byte* data, word32 dataLen, WP11_Object* privKey) int ret = 0; word32 idx = 0; - ret = wc_InitRsaKey_ex(privKey->data.rsaKey, NULL, privKey->slot->devId); + ret = wc_InitRsaKey_ex(privKey->data.rsaKey, NULL, privKey->devId); if (ret == 0) { ret = wc_RsaPrivateKeyDecode(data, &idx, privKey->data.rsaKey, dataLen); } @@ -9593,7 +9624,7 @@ int WP11_Rsa_PrivKey2PubKey(WP11_Object* privKey, WP11_Object* pubKey, int ret; word32 idx = 0; - ret = wc_InitRsaKey_ex(pubKey->data.rsaKey, NULL, pubKey->slot->devId); + ret = wc_InitRsaKey_ex(pubKey->data.rsaKey, NULL, pubKey->devId); if (ret == 0) { ret = wc_RsaKeyToPublicDer(privKey->data.rsaKey, workbuf, worksz); if (ret >= 0) { @@ -9649,7 +9680,7 @@ int WP11_Rsa_GenerateKeyPair(WP11_Object* pub, WP11_Object* priv, if (ret == 0) { ret = Rng_New(&slot->token.rng, &slot->token.rngLock, &rng); if (ret == 0) { - ret = wc_InitRsaKey_ex(priv->data.rsaKey, NULL, priv->slot->devId); + ret = wc_InitRsaKey_ex(priv->data.rsaKey, NULL, priv->devId); if (ret == 0) { #ifdef WOLFPKCS11_TPM priv->slot->tpmCtx.rsaKeyGen = priv->tpmKey; @@ -10381,7 +10412,7 @@ int WP11_Ec_GenerateKeyPair(WP11_Object* pub, WP11_Object* priv, int ret = 0; WC_RNG rng; - ret = wc_ecc_init_ex(priv->data.ecKey, NULL, priv->slot->devId); + ret = wc_ecc_init_ex(priv->data.ecKey, NULL, priv->devId); if (ret == 0) { #ifdef WOLFPKCS11_TPM CK_BBOOL isSign = CK_FALSE; @@ -10751,7 +10782,7 @@ int WP11_EC_Derive(unsigned char* point, word32 pointLen, unsigned char* key, } } - ret = wc_ecc_init_ex(&pubKey, NULL, priv->slot->devId); + ret = wc_ecc_init_ex(&pubKey, NULL, priv->devId); if (ret == 0) { if (priv->data.ecKey->dp) { ret = wc_ecc_import_x963_ex(x963Data, x963Len, &pubKey, @@ -11010,7 +11041,7 @@ int WP11_AesCbc_DeriveKey(unsigned char* plain, word32 plainSz, return BAD_FUNC_ARG; XMEMSET(&aes, 0, sizeof(aes)); - ret = wc_AesInit(&aes, NULL, key->slot->devId); + ret = wc_AesInit(&aes, NULL, key->devId); if (ret == 0) { ret = wc_AesSetKey(&aes, key->data.symmKey->data, key->data.symmKey->len, iv, AES_ENCRYPTION); @@ -11683,7 +11714,7 @@ int WP11_AesGcm_Encrypt(unsigned char* plain, word32 plainSz, word32 authTagSz = gcm->tagBits / 8; unsigned char* authTag = enc + plainSz; - ret = wc_AesInit(&aes, NULL, session->devId); + ret = wc_AesInit(&aes, NULL, secret->devId); if (ret == 0) { if (secret->onToken) WP11_Lock_LockRO(secret->lock); @@ -11735,7 +11766,7 @@ int WP11_AesGcm_EncryptUpdate(unsigned char* plain, word32 plainSz, word32 authTagSz = gcm->tagBits / 8; unsigned char* authTag = gcm->authTag; - ret = wc_AesInit(&aes, NULL, session->devId); + ret = wc_AesInit(&aes, NULL, secret->devId); if (ret == 0) { if (secret->onToken) WP11_Lock_LockRO(secret->lock); @@ -11815,7 +11846,7 @@ int WP11_AesGcm_Decrypt(unsigned char* enc, word32 encSz, unsigned char* dec, word32 authTagSz = gcm->tagBits / 8; unsigned char* authTag = enc + encSz - authTagSz; - ret = wc_AesInit(&aes, NULL, session->devId); + ret = wc_AesInit(&aes, NULL, secret->devId); if (ret == 0) { if (secret->onToken) { WP11_Lock_LockRO(secret->lock); @@ -11977,7 +12008,7 @@ int WP11_AesCcm_Encrypt(unsigned char* plain, word32 plainSz, word32 authTagSz = ccm->macSz; unsigned char* authTag = enc + plainSz; - ret = wc_AesInit(&aes, NULL, session->devId); + ret = wc_AesInit(&aes, NULL, secret->devId); if (ret == 0) { if (secret->onToken) WP11_Lock_LockRO(secret->lock); @@ -12032,7 +12063,7 @@ int WP11_AesCcm_Decrypt(unsigned char* enc, word32 encSz, unsigned char* dec, unsigned char* authTag = enc + encSz - authTagSz; encSz -= authTagSz; - ret = wc_AesInit(&aes, NULL, session->devId); + ret = wc_AesInit(&aes, NULL, secret->devId); if (ret == 0) { if (secret->onToken) WP11_Lock_LockRO(secret->lock); @@ -12088,7 +12119,7 @@ int WP11_AesEcb_Encrypt(unsigned char* plain, word32 plainSz, Aes aes; WP11_Data* key; - ret = wc_AesInit(&aes, NULL, session->devId); + ret = wc_AesInit(&aes, NULL, secret->devId); if (ret == 0) { if (secret->onToken) WP11_Lock_LockRO(secret->lock); @@ -12105,6 +12136,7 @@ int WP11_AesEcb_Encrypt(unsigned char* plain, word32 plainSz, wc_AesFree(&aes); } + (void)session; return ret; } @@ -12129,7 +12161,7 @@ int WP11_AesEcb_Decrypt(unsigned char* enc, word32 encSz, unsigned char* dec, Aes aes; WP11_Data* key; - ret = wc_AesInit(&aes, NULL, session->devId); + ret = wc_AesInit(&aes, NULL, secret->devId); if (ret == 0) { if (secret->onToken) WP11_Lock_LockRO(secret->lock); @@ -12148,6 +12180,7 @@ int WP11_AesEcb_Decrypt(unsigned char* enc, word32 encSz, unsigned char* dec, wc_AesFree(&aes); } + (void)session; return ret; } #endif /* HAVE_AESECB */ diff --git a/wolfpkcs11/internal.h b/wolfpkcs11/internal.h index 97f37d15..15f84a0d 100644 --- a/wolfpkcs11/internal.h +++ b/wolfpkcs11/internal.h @@ -386,6 +386,7 @@ WP11_LOCAL int WP11_Object_Copy(WP11_Object *src, WP11_Object *dest); WP11_LOCAL CK_OBJECT_HANDLE WP11_Object_GetHandle(WP11_Object* object); WP11_LOCAL CK_KEY_TYPE WP11_Object_GetType(WP11_Object* object); +WP11_LOCAL CK_ULONG WP11_Object_GetDevId(WP11_Object* object); WP11_LOCAL int WP11_Object_SetRsaKey(WP11_Object* object, unsigned char** data, CK_ULONG* len); diff --git a/wolfpkcs11/pkcs11.h b/wolfpkcs11/pkcs11.h index 48a976f7..36982f7e 100644 --- a/wolfpkcs11/pkcs11.h +++ b/wolfpkcs11/pkcs11.h @@ -57,6 +57,10 @@ extern "C" { #define CKA_NSS (CKA_VENDOR_DEFINED | CK_VENDOR_NSS) #endif +#define CK_VENDOR_WOLFSSL_DEVID 0x574F4C46L +/* Set the crypto callback device ID to be used with the object */ +#define CKA_WOLFSSL_DEVID (CKA_VENDOR_DEFINED | CK_VENDOR_WOLFSSL_DEVID) + #ifndef NULL_PTR #define NULL_PTR 0 #endif