From 48a1eadfbc17e793db13481ae474cc5e48ffc176 Mon Sep 17 00:00:00 2001 From: Devin AI <158243242+devin-ai-integration[bot]@users.noreply.github.com> Date: Thu, 19 Jun 2025 15:07:33 +0000 Subject: [PATCH 01/13] Add debug messaging system to wolfPKCS11 - Add DEBUG_WOLFPKCS11 compile flag support for conditional debug compilation - Implement wolfPKCS11_Debugging_On() and wolfPKCS11_Debugging_Off() functions - Add WOLFPKCS11_ENTER/LEAVE/MSG debug macros with printf output - Instrument public functions in wolfpkcs11.c, crypto.c, and slot.c - Add debug control function declarations to public API (pkcs11.h) - Include debug test program demonstrating functionality - Follow wolfSSL logging patterns for consistency Debug system provides function enter/exit tracing and parameter logging for public PKCS#11 functions when enabled with --enable-debug configure option. Co-Authored-By: andrew@wolfssl.com --- debug_test.c | 69 ++++++++++++++++ src/crypto.c | 80 ++++++++++++++----- src/internal.c | 16 ++++ src/slot.c | 179 +++++++++++++++++++++++++++++++----------- src/wolfpkcs11.c | 60 ++++++++++---- wolfpkcs11/internal.h | 17 ++++ wolfpkcs11/pkcs11.h | 6 ++ 7 files changed, 349 insertions(+), 78 deletions(-) create mode 100644 debug_test.c diff --git a/debug_test.c b/debug_test.c new file mode 100644 index 00000000..f77c296c --- /dev/null +++ b/debug_test.c @@ -0,0 +1,69 @@ +#include +#include "wolfpkcs11/pkcs11.h" + +int main() { + CK_RV rv; + CK_FUNCTION_LIST_PTR pFunctionList; + + printf("=== wolfPKCS11 Debug Test Program ===\n"); + +#ifdef DEBUG_WOLFPKCS11 + printf("Debug mode is ENABLED (DEBUG_WOLFPKCS11 defined)\n"); + + printf("\nTesting debug control functions:\n"); + wolfPKCS11_Debugging_On(); + printf("Debug enabled\n"); + + wolfPKCS11_Debugging_Off(); + printf("Debug disabled\n"); + + wolfPKCS11_Debugging_On(); + printf("Debug re-enabled\n"); + + printf("\nTesting PKCS#11 functions with debug output:\n"); + rv = C_GetFunctionList(&pFunctionList); + printf("C_GetFunctionList returned: %lu\n", (unsigned long)rv); + + if (rv == CKR_OK && pFunctionList != NULL) { + rv = pFunctionList->C_Initialize(NULL); + printf("C_Initialize returned: %lu\n", (unsigned long)rv); + + if (rv == CKR_OK) { + CK_INFO info; + rv = pFunctionList->C_GetInfo(&info); + printf("C_GetInfo returned: %lu\n", (unsigned long)rv); + + pFunctionList->C_Finalize(NULL); + printf("C_Finalize called\n"); + } + } + + wolfPKCS11_Debugging_Off(); + printf("Debug disabled at end\n"); + +#else + printf("Debug mode is DISABLED (DEBUG_WOLFPKCS11 not defined)\n"); + printf("Debug functions and macros are compiled out\n"); + + printf("\nTesting PKCS#11 functions without debug output:\n"); + rv = C_GetFunctionList(&pFunctionList); + printf("C_GetFunctionList returned: %lu\n", (unsigned long)rv); + + if (rv == CKR_OK && pFunctionList != NULL) { + rv = pFunctionList->C_Initialize(NULL); + printf("C_Initialize returned: %lu\n", (unsigned long)rv); + + if (rv == CKR_OK) { + CK_INFO info; + rv = pFunctionList->C_GetInfo(&info); + printf("C_GetInfo returned: %lu\n", (unsigned long)rv); + + pFunctionList->C_Finalize(NULL); + printf("C_Finalize called\n"); + } + } +#endif + + printf("\n=== Test Complete ===\n"); + return 0; +} diff --git a/src/crypto.c b/src/crypto.c index faa592f4..5590a966 100644 --- a/src/crypto.c +++ b/src/crypto.c @@ -1008,22 +1008,44 @@ CK_RV C_CreateObject(CK_SESSION_HANDLE hSession, CK_ATTRIBUTE_PTR pTemplate, WP11_Session* session; WP11_Object* object; - if (!WP11_Library_IsInitialized()) - return CKR_CRYPTOKI_NOT_INITIALIZED; - if (WP11_Session_Get(hSession, &session) != 0) - return CKR_SESSION_HANDLE_INVALID; - if (pTemplate == NULL || phObject == NULL) - return CKR_ARGUMENTS_BAD; - if (!WP11_Session_IsRW(session)) - return CKR_SESSION_READ_ONLY; + WOLFPKCS11_ENTER("C_CreateObject"); + #ifdef DEBUG_WOLFPKCS11 + if (wolfpkcs11_debugging) { + printf(" hSession=%lu, ulCount=%lu\n", (unsigned long)hSession, (unsigned long)ulCount); + } + #endif + + if (!WP11_Library_IsInitialized()) { + rv = CKR_CRYPTOKI_NOT_INITIALIZED; + WOLFPKCS11_LEAVE("C_CreateObject", rv); + return rv; + } + if (WP11_Session_Get(hSession, &session) != 0) { + rv = CKR_SESSION_HANDLE_INVALID; + WOLFPKCS11_LEAVE("C_CreateObject", rv); + return rv; + } + if (pTemplate == NULL || phObject == NULL) { + rv = CKR_ARGUMENTS_BAD; + WOLFPKCS11_LEAVE("C_CreateObject", rv); + return rv; + } + if (!WP11_Session_IsRW(session)) { + rv = CKR_SESSION_READ_ONLY; + WOLFPKCS11_LEAVE("C_CreateObject", rv); + return rv; + } rv = CreateObject(session, pTemplate, ulCount, &object); - if (rv != CKR_OK) + if (rv != CKR_OK) { + WOLFPKCS11_LEAVE("C_CreateObject", rv); return rv; + } rv = AddObject(session, object, pTemplate, ulCount, phObject); if (rv != CKR_OK) WP11_Object_Free(object); + WOLFPKCS11_LEAVE("C_CreateObject", rv); return rv; } @@ -1134,24 +1156,46 @@ CK_RV C_DestroyObject(CK_SESSION_HANDLE hSession, CK_OBJECT_HANDLE hObject) { int ret; + CK_RV rv; WP11_Session* session; WP11_Object* obj = NULL; - if (!WP11_Library_IsInitialized()) - return CKR_CRYPTOKI_NOT_INITIALIZED; - if (WP11_Session_Get(hSession, &session) != 0) - return CKR_SESSION_HANDLE_INVALID; - if (!WP11_Session_IsRW(session)) - return CKR_SESSION_READ_ONLY; + WOLFPKCS11_ENTER("C_DestroyObject"); + #ifdef DEBUG_WOLFPKCS11 + if (wolfpkcs11_debugging) { + printf(" hSession=%lu, hObject=%lu\n", (unsigned long)hSession, (unsigned long)hObject); + } + #endif + + if (!WP11_Library_IsInitialized()) { + rv = CKR_CRYPTOKI_NOT_INITIALIZED; + WOLFPKCS11_LEAVE("C_DestroyObject", rv); + return rv; + } + if (WP11_Session_Get(hSession, &session) != 0) { + rv = CKR_SESSION_HANDLE_INVALID; + WOLFPKCS11_LEAVE("C_DestroyObject", rv); + return rv; + } + if (!WP11_Session_IsRW(session)) { + rv = CKR_SESSION_READ_ONLY; + WOLFPKCS11_LEAVE("C_DestroyObject", rv); + return rv; + } ret = WP11_Object_Find(session, hObject, &obj); - if (ret != 0) - return CKR_OBJECT_HANDLE_INVALID; + if (ret != 0) { + rv = CKR_OBJECT_HANDLE_INVALID; + WOLFPKCS11_LEAVE("C_DestroyObject", rv); + return rv; + } WP11_Session_RemoveObject(session, obj); WP11_Object_Free(obj); - return CKR_OK; + rv = CKR_OK; + WOLFPKCS11_LEAVE("C_DestroyObject", rv); + return rv; } /** diff --git a/src/internal.c b/src/internal.c index a5897fc0..32397892 100644 --- a/src/internal.c +++ b/src/internal.c @@ -164,6 +164,22 @@ typedef struct WP11_Lock { } WP11_Lock; #endif +#ifdef DEBUG_WOLFPKCS11 +int wolfpkcs11_debugging = 0; + +void wolfPKCS11_Debugging_On(void) +{ + wolfpkcs11_debugging = 1; + printf("wolfPKCS11 debug logging enabled\n"); +} + +void wolfPKCS11_Debugging_Off(void) +{ + printf("wolfPKCS11 debug logging disabled\n"); + wolfpkcs11_debugging = 0; +} +#endif + /* Symmetric key data. */ typedef struct WP11_Data { diff --git a/src/slot.c b/src/slot.c index 1c8ef420..ab8b8200 100644 --- a/src/slot.c +++ b/src/slot.c @@ -46,19 +46,41 @@ CK_RV C_GetSlotList(CK_BBOOL tokenPresent, CK_SLOT_ID_PTR pSlotList, CK_ULONG_PTR pulCount) { int ret; + CK_RV rv; - if (!WP11_Library_IsInitialized()) - return CKR_CRYPTOKI_NOT_INITIALIZED; - if (tokenPresent != CK_FALSE && tokenPresent != CK_TRUE) - return CKR_ARGUMENTS_BAD; - if (pulCount == NULL) - return CKR_ARGUMENTS_BAD; + WOLFPKCS11_ENTER("C_GetSlotList"); + #ifdef DEBUG_WOLFPKCS11 + if (wolfpkcs11_debugging) { + printf(" tokenPresent=%s\n", tokenPresent ? "TRUE" : "FALSE"); + } + #endif + + if (!WP11_Library_IsInitialized()) { + rv = CKR_CRYPTOKI_NOT_INITIALIZED; + WOLFPKCS11_LEAVE("C_GetSlotList", rv); + return rv; + } + if (tokenPresent != CK_FALSE && tokenPresent != CK_TRUE) { + rv = CKR_ARGUMENTS_BAD; + WOLFPKCS11_LEAVE("C_GetSlotList", rv); + return rv; + } + if (pulCount == NULL) { + rv = CKR_ARGUMENTS_BAD; + WOLFPKCS11_LEAVE("C_GetSlotList", rv); + return rv; + } ret = WP11_GetSlotList(tokenPresent, pSlotList, pulCount); - if (ret == BUFFER_E) - return CKR_BUFFER_TOO_SMALL; + if (ret == BUFFER_E) { + rv = CKR_BUFFER_TOO_SMALL; + WOLFPKCS11_LEAVE("C_GetSlotList", rv); + return rv; + } - return CKR_OK; + rv = CKR_OK; + WOLFPKCS11_LEAVE("C_GetSlotList", rv); + return rv; } /* Index into slot id string to place number. */ @@ -86,19 +108,39 @@ static CK_SLOT_INFO slotInfoTemplate = { */ CK_RV C_GetSlotInfo(CK_SLOT_ID slotID, CK_SLOT_INFO_PTR pInfo) { - if (!WP11_Library_IsInitialized()) - return CKR_CRYPTOKI_NOT_INITIALIZED; - if (!WP11_SlotIdValid(slotID)) - return CKR_SLOT_ID_INVALID; - if (pInfo == NULL) - return CKR_ARGUMENTS_BAD; + CK_RV rv; + + WOLFPKCS11_ENTER("C_GetSlotInfo"); + #ifdef DEBUG_WOLFPKCS11 + if (wolfpkcs11_debugging) { + printf(" slotID=%lu\n", (unsigned long)slotID); + } + #endif + + if (!WP11_Library_IsInitialized()) { + rv = CKR_CRYPTOKI_NOT_INITIALIZED; + WOLFPKCS11_LEAVE("C_GetSlotInfo", rv); + return rv; + } + if (!WP11_SlotIdValid(slotID)) { + rv = CKR_SLOT_ID_INVALID; + WOLFPKCS11_LEAVE("C_GetSlotInfo", rv); + return rv; + } + if (pInfo == NULL) { + rv = CKR_ARGUMENTS_BAD; + WOLFPKCS11_LEAVE("C_GetSlotInfo", rv); + return rv; + } XMEMCPY(pInfo, &slotInfoTemplate, sizeof(slotInfoTemplate)); /* Put in the slot id value as two decimal digits. */ pInfo->slotDescription[SLOT_ID_IDX + 0] = ((slotID / 10) % 10) + '0'; pInfo->slotDescription[SLOT_ID_IDX + 1] = ((slotID ) % 10) + '0'; - return CKR_OK; + rv = CKR_OK; + WOLFPKCS11_LEAVE("C_GetSlotInfo", rv); + return rv; } static CK_RV checkPinLen(CK_ULONG pinLen) @@ -1388,47 +1430,96 @@ CK_RV C_Login(CK_SESSION_HANDLE hSession, CK_USER_TYPE userType, CK_UTF8CHAR_PTR pPin, CK_ULONG ulPinLen) { int ret; + CK_RV rv; WP11_Slot* slot; WP11_Session* session; - if (!WP11_Library_IsInitialized()) - return CKR_CRYPTOKI_NOT_INITIALIZED; - if (WP11_Session_Get(hSession, &session) != 0) - return CKR_SESSION_HANDLE_INVALID; - if (pPin == NULL) - return CKR_ARGUMENTS_BAD; + WOLFPKCS11_ENTER("C_Login"); + #ifdef DEBUG_WOLFPKCS11 + if (wolfpkcs11_debugging) { + printf(" hSession=%lu, userType=%lu, ulPinLen=%lu\n", + (unsigned long)hSession, (unsigned long)userType, (unsigned long)ulPinLen); + } + #endif - if (checkPinLen(ulPinLen) != CKR_OK) - return CKR_PIN_INCORRECT; + if (!WP11_Library_IsInitialized()) { + rv = CKR_CRYPTOKI_NOT_INITIALIZED; + WOLFPKCS11_LEAVE("C_Login", rv); + return rv; + } + if (WP11_Session_Get(hSession, &session) != 0) { + rv = CKR_SESSION_HANDLE_INVALID; + WOLFPKCS11_LEAVE("C_Login", rv); + return rv; + } + if (pPin == NULL) { + rv = CKR_ARGUMENTS_BAD; + WOLFPKCS11_LEAVE("C_Login", rv); + return rv; + } + + if (checkPinLen(ulPinLen) != CKR_OK) { + rv = CKR_PIN_INCORRECT; + WOLFPKCS11_LEAVE("C_Login", rv); + return rv; + } slot = WP11_Session_GetSlot(session); if (userType == CKU_SO) { ret = WP11_Slot_SOLogin(slot, (char*)pPin, (int)ulPinLen); - if (ret == LOGGED_IN_E) - return CKR_USER_ALREADY_LOGGED_IN; - if (ret == READ_ONLY_E) - return CKR_SESSION_READ_ONLY_EXISTS; - if (ret == PIN_NOT_SET_E) - return CKR_USER_PIN_NOT_INITIALIZED; - if (ret != 0) - return CKR_PIN_INCORRECT; - + if (ret == LOGGED_IN_E) { + rv = CKR_USER_ALREADY_LOGGED_IN; + WOLFPKCS11_LEAVE("C_Login", rv); + return rv; + } + if (ret == READ_ONLY_E) { + rv = CKR_SESSION_READ_ONLY_EXISTS; + WOLFPKCS11_LEAVE("C_Login", rv); + return rv; + } + if (ret == PIN_NOT_SET_E) { + rv = CKR_USER_PIN_NOT_INITIALIZED; + WOLFPKCS11_LEAVE("C_Login", rv); + return rv; + } + if (ret != 0) { + rv = CKR_PIN_INCORRECT; + WOLFPKCS11_LEAVE("C_Login", rv); + return rv; + } } else if (userType == CKU_USER) { ret = WP11_Slot_UserLogin(slot, (char*)pPin, (int)ulPinLen); - if (ret == LOGGED_IN_E) - return CKR_USER_ALREADY_LOGGED_IN; - if (ret == PIN_NOT_SET_E) - return CKR_USER_PIN_NOT_INITIALIZED; - if (ret != 0) - return CKR_PIN_INCORRECT; + if (ret == LOGGED_IN_E) { + rv = CKR_USER_ALREADY_LOGGED_IN; + WOLFPKCS11_LEAVE("C_Login", rv); + return rv; + } + if (ret == PIN_NOT_SET_E) { + rv = CKR_USER_PIN_NOT_INITIALIZED; + WOLFPKCS11_LEAVE("C_Login", rv); + return rv; + } + if (ret != 0) { + rv = CKR_PIN_INCORRECT; + WOLFPKCS11_LEAVE("C_Login", rv); + return rv; + } + } + else if (userType == CKU_CONTEXT_SPECIFIC) { + rv = CKR_OPERATION_NOT_INITIALIZED; + WOLFPKCS11_LEAVE("C_Login", rv); + return rv; + } + else { + rv = CKR_USER_TYPE_INVALID; + WOLFPKCS11_LEAVE("C_Login", rv); + return rv; } - else if (userType == CKU_CONTEXT_SPECIFIC) - return CKR_OPERATION_NOT_INITIALIZED; - else - return CKR_USER_TYPE_INVALID; - return CKR_OK; + rv = CKR_OK; + WOLFPKCS11_LEAVE("C_Login", rv); + return rv; } /** diff --git a/src/wolfpkcs11.c b/src/wolfpkcs11.c index 4b510b43..d9823da9 100644 --- a/src/wolfpkcs11.c +++ b/src/wolfpkcs11.c @@ -109,12 +109,19 @@ static CK_FUNCTION_LIST wolfpkcs11FunctionList = { */ CK_RV C_GetFunctionList(CK_FUNCTION_LIST_PTR_PTR ppFunctionList) { - if (ppFunctionList == NULL) - return CKR_ARGUMENTS_BAD; + CK_RV ret; + WOLFPKCS11_ENTER("C_GetFunctionList"); + + if (ppFunctionList == NULL) { + ret = CKR_ARGUMENTS_BAD; + WOLFPKCS11_LEAVE("C_GetFunctionList", ret); + return ret; + } *ppFunctionList = &wolfpkcs11FunctionList; - - return CKR_OK; + ret = CKR_OK; + WOLFPKCS11_LEAVE("C_GetFunctionList", ret); + return ret; } /** @@ -126,12 +133,19 @@ CK_RV C_GetFunctionList(CK_FUNCTION_LIST_PTR_PTR ppFunctionList) */ CK_RV C_Initialize(CK_VOID_PTR pInitArgs) { - if (WP11_Library_Init() != 0) - return CKR_FUNCTION_FAILED; + CK_RV ret; + WOLFPKCS11_ENTER("C_Initialize"); + + if (WP11_Library_Init() != 0) { + ret = CKR_FUNCTION_FAILED; + WOLFPKCS11_LEAVE("C_Initialize", ret); + return ret; + } (void)pInitArgs; - - return CKR_OK; + ret = CKR_OK; + WOLFPKCS11_LEAVE("C_Initialize", ret); + return ret; } /** @@ -142,11 +156,15 @@ CK_RV C_Initialize(CK_VOID_PTR pInitArgs) */ CK_RV C_Finalize(CK_VOID_PTR pReserved) { + CK_RV ret; + WOLFPKCS11_ENTER("C_Finalize"); + WP11_Library_Final(); (void)pReserved; - - return CKR_OK; + ret = CKR_OK; + WOLFPKCS11_LEAVE("C_Finalize", ret); + return ret; } /* Information about the Crypto-Ki library. */ @@ -168,13 +186,23 @@ static CK_INFO wolfpkcs11Info = { */ CK_RV C_GetInfo(CK_INFO_PTR pInfo) { - if (!WP11_Library_IsInitialized()) - return CKR_CRYPTOKI_NOT_INITIALIZED; - if (pInfo == NULL) - return CKR_ARGUMENTS_BAD; + CK_RV ret; + WOLFPKCS11_ENTER("C_GetInfo"); + + if (!WP11_Library_IsInitialized()) { + ret = CKR_CRYPTOKI_NOT_INITIALIZED; + WOLFPKCS11_LEAVE("C_GetInfo", ret); + return ret; + } + if (pInfo == NULL) { + ret = CKR_ARGUMENTS_BAD; + WOLFPKCS11_LEAVE("C_GetInfo", ret); + return ret; + } XMEMCPY(pInfo, &wolfpkcs11Info, sizeof(wolfpkcs11Info)); - - return CKR_OK; + ret = CKR_OK; + WOLFPKCS11_LEAVE("C_GetInfo", ret); + return ret; } diff --git a/wolfpkcs11/internal.h b/wolfpkcs11/internal.h index d34cedcc..f0954a5e 100644 --- a/wolfpkcs11/internal.h +++ b/wolfpkcs11/internal.h @@ -613,6 +613,23 @@ int WP11_GetOperationState(WP11_Session* session, unsigned char* stateData, int WP11_SetOperationState(WP11_Session* session, unsigned char* stateData, unsigned long stateDataLen); +#ifdef DEBUG_WOLFPKCS11 +extern int wolfpkcs11_debugging; +void wolfPKCS11_Debugging_On(void); +void wolfPKCS11_Debugging_Off(void); + +#define WOLFPKCS11_ENTER(funcName) \ + do { if (wolfpkcs11_debugging) printf("WOLFPKCS11 ENTER: %s\n", funcName); } while(0) +#define WOLFPKCS11_LEAVE(funcName, ret) \ + do { if (wolfpkcs11_debugging) printf("WOLFPKCS11 LEAVE: %s, returning %lu\n", funcName, (unsigned long)ret); } while(0) +#define WOLFPKCS11_MSG(msg) \ + do { if (wolfpkcs11_debugging) printf("WOLFPKCS11: %s\n", msg); } while(0) +#else +#define WOLFPKCS11_ENTER(funcName) +#define WOLFPKCS11_LEAVE(funcName, ret) +#define WOLFPKCS11_MSG(msg) +#endif + #ifdef __cplusplus } #endif diff --git a/wolfpkcs11/pkcs11.h b/wolfpkcs11/pkcs11.h index 90de21b9..95a1c1e8 100644 --- a/wolfpkcs11/pkcs11.h +++ b/wolfpkcs11/pkcs11.h @@ -1095,6 +1095,12 @@ struct CK_FUNCTION_LIST { }; +#ifdef DEBUG_WOLFPKCS11 +/* Debug control functions */ +WP11_API void wolfPKCS11_Debugging_On(void); +WP11_API void wolfPKCS11_Debugging_Off(void); +#endif + #ifdef __cplusplus } #endif From 9cc839681f38af251b85eebf1eff8cd3d18cc68b Mon Sep 17 00:00:00 2001 From: Devin AI <158243242+devin-ai-integration[bot]@users.noreply.github.com> Date: Thu, 19 Jun 2025 16:20:44 +0000 Subject: [PATCH 02/13] Address user feedback on debug messaging system - Replace direct printf calls with WOLFPKCS11_MSG macro - Add user-customizable macro support with #ifndef guards - Instrument all public PKCS#11 functions across crypto.c, slot.c, and wolfpkcs11.c - Ensure consistent debug logging pattern with enter/exit tracing and parameter details Co-Authored-By: andrew@wolfssl.com --- src/crypto.c | 1419 +++++++++++++++++++++++++++++++++-------- src/slot.c | 658 +++++++++++++++---- wolfpkcs11/internal.h | 6 + 3 files changed, 1671 insertions(+), 412 deletions(-) diff --git a/src/crypto.c b/src/crypto.c index 5590a966..bebc781e 100644 --- a/src/crypto.c +++ b/src/crypto.c @@ -1011,7 +1011,9 @@ CK_RV C_CreateObject(CK_SESSION_HANDLE hSession, CK_ATTRIBUTE_PTR pTemplate, WOLFPKCS11_ENTER("C_CreateObject"); #ifdef DEBUG_WOLFPKCS11 if (wolfpkcs11_debugging) { - printf(" hSession=%lu, ulCount=%lu\n", (unsigned long)hSession, (unsigned long)ulCount); + char paramStr[256]; + snprintf(paramStr, sizeof(paramStr), " hSession=%lu, ulCount=%lu", (unsigned long)hSession, (unsigned long)ulCount); + WOLFPKCS11_MSG(paramStr); } #endif @@ -1085,14 +1087,35 @@ CK_RV C_CopyObject(CK_SESSION_HANDLE hSession, CK_OBJECT_HANDLE hObject, CK_KEY_TYPE keyType; int onToken = 0; - if (!WP11_Library_IsInitialized()) - return CKR_CRYPTOKI_NOT_INITIALIZED; - if (WP11_Session_Get(hSession, &session) != 0) - return CKR_SESSION_HANDLE_INVALID; - if (pTemplate == NULL || phNewObject == NULL) - return CKR_ARGUMENTS_BAD; - if (!WP11_Session_IsRW(session)) - return CKR_SESSION_READ_ONLY; + WOLFPKCS11_ENTER("C_CopyObject"); + #ifdef DEBUG_WOLFPKCS11 + if (wolfpkcs11_debugging) { + char paramStr[256]; + snprintf(paramStr, sizeof(paramStr), " hSession=%lu, hObject=%lu, ulCount=%lu", (unsigned long)hSession, (unsigned long)hObject, (unsigned long)ulCount); + WOLFPKCS11_MSG(paramStr); + } + #endif + + if (!WP11_Library_IsInitialized()) { + rv = CKR_CRYPTOKI_NOT_INITIALIZED; + WOLFPKCS11_LEAVE("C_CopyObject", rv); + return rv; + } + if (WP11_Session_Get(hSession, &session) != 0) { + rv = CKR_SESSION_HANDLE_INVALID; + WOLFPKCS11_LEAVE("C_CopyObject", rv); + return rv; + } + if (pTemplate == NULL || phNewObject == NULL) { + rv = CKR_ARGUMENTS_BAD; + WOLFPKCS11_LEAVE("C_CopyObject", rv); + return rv; + } + if (!WP11_Session_IsRW(session)) { + rv = CKR_SESSION_READ_ONLY; + WOLFPKCS11_LEAVE("C_CopyObject", rv); + return rv; + } /* Need key type and whether object is to be on the token to create a new * object. Get the object type from original object and where to store @@ -1163,7 +1186,9 @@ CK_RV C_DestroyObject(CK_SESSION_HANDLE hSession, WOLFPKCS11_ENTER("C_DestroyObject"); #ifdef DEBUG_WOLFPKCS11 if (wolfpkcs11_debugging) { - printf(" hSession=%lu, hObject=%lu\n", (unsigned long)hSession, (unsigned long)hObject); + char paramStr[256]; + snprintf(paramStr, sizeof(paramStr), " hSession=%lu, hObject=%lu", (unsigned long)hSession, (unsigned long)hObject); + WOLFPKCS11_MSG(paramStr); } #endif @@ -1216,24 +1241,48 @@ CK_RV C_DestroyObject(CK_SESSION_HANDLE hSession, CK_RV C_GetObjectSize(CK_SESSION_HANDLE hSession, CK_OBJECT_HANDLE hObject, CK_ULONG_PTR pulSize) { + CK_RV rv; int ret; WP11_Session* session; WP11_Object* obj = NULL; - if (!WP11_Library_IsInitialized()) - return CKR_CRYPTOKI_NOT_INITIALIZED; - if (WP11_Session_Get(hSession, &session) != 0) - return CKR_SESSION_HANDLE_INVALID; - if (pulSize == NULL) - return CKR_ARGUMENTS_BAD; + WOLFPKCS11_ENTER("C_GetObjectSize"); + #ifdef DEBUG_WOLFPKCS11 + if (wolfpkcs11_debugging) { + char paramStr[256]; + snprintf(paramStr, sizeof(paramStr), " hSession=%lu, hObject=%lu", (unsigned long)hSession, (unsigned long)hObject); + WOLFPKCS11_MSG(paramStr); + } + #endif + + if (!WP11_Library_IsInitialized()) { + rv = CKR_CRYPTOKI_NOT_INITIALIZED; + WOLFPKCS11_LEAVE("C_GetObjectSize", rv); + return rv; + } + if (WP11_Session_Get(hSession, &session) != 0) { + rv = CKR_SESSION_HANDLE_INVALID; + WOLFPKCS11_LEAVE("C_GetObjectSize", rv); + return rv; + } + if (pulSize == NULL) { + rv = CKR_ARGUMENTS_BAD; + WOLFPKCS11_LEAVE("C_GetObjectSize", rv); + return rv; + } ret = WP11_Object_Find(session, hObject, &obj); - if (ret != 0) - return CKR_OBJECT_HANDLE_INVALID; + if (ret != 0) { + rv = CKR_OBJECT_HANDLE_INVALID; + WOLFPKCS11_LEAVE("C_GetObjectSize", rv); + return rv; + } *pulSize = CK_UNAVAILABLE_INFORMATION; - return CKR_OK; + rv = CKR_OK; + WOLFPKCS11_LEAVE("C_GetObjectSize", rv); + return rv; } @@ -1266,39 +1315,75 @@ CK_RV C_GetAttributeValue(CK_SESSION_HANDLE hSession, CK_ATTRIBUTE* attr; int i; - if (!WP11_Library_IsInitialized()) - return CKR_CRYPTOKI_NOT_INITIALIZED; - if (WP11_Session_Get(hSession, &session) != 0) - return CKR_SESSION_HANDLE_INVALID; - if (pTemplate == NULL) - return CKR_ARGUMENTS_BAD; + WOLFPKCS11_ENTER("C_GetAttributeValue"); + #ifdef DEBUG_WOLFPKCS11 + if (wolfpkcs11_debugging) { + char paramStr[256]; + snprintf(paramStr, sizeof(paramStr), " hSession=%lu, hObject=%lu, ulCount=%lu", (unsigned long)hSession, (unsigned long)hObject, (unsigned long)ulCount); + WOLFPKCS11_MSG(paramStr); + } + #endif + + if (!WP11_Library_IsInitialized()) { + rv = CKR_CRYPTOKI_NOT_INITIALIZED; + WOLFPKCS11_LEAVE("C_GetAttributeValue", rv); + return rv; + } + if (WP11_Session_Get(hSession, &session) != 0) { + rv = CKR_SESSION_HANDLE_INVALID; + WOLFPKCS11_LEAVE("C_GetAttributeValue", rv); + return rv; + } + if (pTemplate == NULL) { + rv = CKR_ARGUMENTS_BAD; + WOLFPKCS11_LEAVE("C_GetAttributeValue", rv); + return rv; + } ret = WP11_Object_Find(session, hObject, &obj); - if (ret != 0) - return CKR_OBJECT_HANDLE_INVALID; + if (ret != 0) { + rv = CKR_OBJECT_HANDLE_INVALID; + WOLFPKCS11_LEAVE("C_GetAttributeValue", rv); + return rv; + } /* Check the value and lengths of attributes based on data type. */ rv = CheckAttributes(pTemplate, ulCount, 0); - if (rv != CKR_OK) + if (rv != CKR_OK) { + WOLFPKCS11_LEAVE("C_GetAttributeValue", rv); return rv; + } for (i = 0; i < (int)ulCount; i++) { attr = &pTemplate[i]; ret = WP11_Object_GetAttr(obj, attr->type, (byte*)attr->pValue, &attr->ulValueLen); - if (ret == BAD_FUNC_ARG) - return CKR_ATTRIBUTE_TYPE_INVALID; - else if (ret == BUFFER_E) - return CKR_BUFFER_TOO_SMALL; - else if (ret == NOT_AVAILABLE_E) - return CK_UNAVAILABLE_INFORMATION; + if (ret == BAD_FUNC_ARG) { + rv = CKR_ATTRIBUTE_TYPE_INVALID; + WOLFPKCS11_LEAVE("C_GetAttributeValue", rv); + return rv; + } + else if (ret == BUFFER_E) { + rv = CKR_BUFFER_TOO_SMALL; + WOLFPKCS11_LEAVE("C_GetAttributeValue", rv); + return rv; + } + else if (ret == NOT_AVAILABLE_E) { + rv = CK_UNAVAILABLE_INFORMATION; + WOLFPKCS11_LEAVE("C_GetAttributeValue", rv); + return rv; + } else if (ret == CKR_ATTRIBUTE_SENSITIVE) rv = ret; - else if (ret != 0) - return CKR_FUNCTION_FAILED; + else if (ret != 0) { + rv = CKR_FUNCTION_FAILED; + WOLFPKCS11_LEAVE("C_GetAttributeValue", rv); + return rv; + } } + WOLFPKCS11_LEAVE("C_GetAttributeValue", rv); return rv; } @@ -1327,24 +1412,51 @@ CK_RV C_SetAttributeValue(CK_SESSION_HANDLE hSession, CK_OBJECT_HANDLE hObject, CK_ATTRIBUTE_PTR pTemplate, CK_ULONG ulCount) { + CK_RV rv; int ret; WP11_Session* session; WP11_Object* obj; - if (!WP11_Library_IsInitialized()) - return CKR_CRYPTOKI_NOT_INITIALIZED; - if (WP11_Session_Get(hSession, &session) != 0) - return CKR_SESSION_HANDLE_INVALID; - if (pTemplate == NULL) - return CKR_ARGUMENTS_BAD; - if (!WP11_Session_IsRW(session)) - return CKR_SESSION_READ_ONLY; + WOLFPKCS11_ENTER("C_SetAttributeValue"); + #ifdef DEBUG_WOLFPKCS11 + if (wolfpkcs11_debugging) { + char paramStr[256]; + snprintf(paramStr, sizeof(paramStr), " hSession=%lu, hObject=%lu, ulCount=%lu", (unsigned long)hSession, (unsigned long)hObject, (unsigned long)ulCount); + WOLFPKCS11_MSG(paramStr); + } + #endif + + if (!WP11_Library_IsInitialized()) { + rv = CKR_CRYPTOKI_NOT_INITIALIZED; + WOLFPKCS11_LEAVE("C_SetAttributeValue", rv); + return rv; + } + if (WP11_Session_Get(hSession, &session) != 0) { + rv = CKR_SESSION_HANDLE_INVALID; + WOLFPKCS11_LEAVE("C_SetAttributeValue", rv); + return rv; + } + if (pTemplate == NULL) { + rv = CKR_ARGUMENTS_BAD; + WOLFPKCS11_LEAVE("C_SetAttributeValue", rv); + return rv; + } + if (!WP11_Session_IsRW(session)) { + rv = CKR_SESSION_READ_ONLY; + WOLFPKCS11_LEAVE("C_SetAttributeValue", rv); + return rv; + } ret = WP11_Object_Find(session, hObject, &obj); - if (ret != 0) - return CKR_OBJECT_HANDLE_INVALID; + if (ret != 0) { + rv = CKR_OBJECT_HANDLE_INVALID; + WOLFPKCS11_LEAVE("C_SetAttributeValue", rv); + return rv; + } - return SetAttributeValue(session, obj, pTemplate, ulCount, CK_FALSE); + rv = SetAttributeValue(session, obj, pTemplate, ulCount, CK_FALSE); + WOLFPKCS11_LEAVE("C_SetAttributeValue", rv); + return rv; } /** @@ -1366,32 +1478,62 @@ CK_RV C_SetAttributeValue(CK_SESSION_HANDLE hSession, CK_RV C_FindObjectsInit(CK_SESSION_HANDLE hSession, CK_ATTRIBUTE_PTR pTemplate, CK_ULONG ulCount) { + CK_RV rv; WP11_Session* session; CK_ATTRIBUTE* attr; int onToken = 1; - if (!WP11_Library_IsInitialized()) - return CKR_CRYPTOKI_NOT_INITIALIZED; - if (WP11_Session_Get(hSession, &session) != 0) - return CKR_SESSION_HANDLE_INVALID; - if (pTemplate == NULL) - return CKR_ARGUMENTS_BAD; + WOLFPKCS11_ENTER("C_FindObjectsInit"); + #ifdef DEBUG_WOLFPKCS11 + if (wolfpkcs11_debugging) { + char paramStr[256]; + snprintf(paramStr, sizeof(paramStr), " hSession=%lu, ulCount=%lu", (unsigned long)hSession, (unsigned long)ulCount); + WOLFPKCS11_MSG(paramStr); + } + #endif - if (WP11_Session_FindInit(session) != 0) - return CKR_OPERATION_ACTIVE; + if (!WP11_Library_IsInitialized()) { + rv = CKR_CRYPTOKI_NOT_INITIALIZED; + WOLFPKCS11_LEAVE("C_FindObjectsInit", rv); + return rv; + } + if (WP11_Session_Get(hSession, &session) != 0) { + rv = CKR_SESSION_HANDLE_INVALID; + WOLFPKCS11_LEAVE("C_FindObjectsInit", rv); + return rv; + } + if (pTemplate == NULL) { + rv = CKR_ARGUMENTS_BAD; + WOLFPKCS11_LEAVE("C_FindObjectsInit", rv); + return rv; + } + + if (WP11_Session_FindInit(session) != 0) { + rv = CKR_OPERATION_ACTIVE; + WOLFPKCS11_LEAVE("C_FindObjectsInit", rv); + return rv; + } FindAttributeType(pTemplate, ulCount, CKA_TOKEN, &attr); if (attr != NULL) { - if (attr->pValue == NULL) - return CKR_ATTRIBUTE_VALUE_INVALID; - if (attr->ulValueLen != sizeof(CK_BBOOL)) - return CKR_ATTRIBUTE_VALUE_INVALID; + if (attr->pValue == NULL) { + rv = CKR_ATTRIBUTE_VALUE_INVALID; + WOLFPKCS11_LEAVE("C_FindObjectsInit", rv); + return rv; + } + if (attr->ulValueLen != sizeof(CK_BBOOL)) { + rv = CKR_ATTRIBUTE_VALUE_INVALID; + WOLFPKCS11_LEAVE("C_FindObjectsInit", rv); + return rv; + } onToken = *(CK_BBOOL*)attr->pValue; } WP11_Session_Find(session, onToken, pTemplate, ulCount); - return CKR_OK; + rv = CKR_OK; + WOLFPKCS11_LEAVE("C_FindObjectsInit", rv); + return rv; } /** @@ -1413,16 +1555,35 @@ CK_RV C_FindObjects(CK_SESSION_HANDLE hSession, CK_ULONG ulMaxObjectCount, CK_ULONG_PTR pulObjectCount) { + CK_RV rv; int i; CK_OBJECT_HANDLE handle; WP11_Session* session; - if (!WP11_Library_IsInitialized()) - return CKR_CRYPTOKI_NOT_INITIALIZED; - if (WP11_Session_Get(hSession, &session) != 0) - return CKR_SESSION_HANDLE_INVALID; - if (phObject == NULL || pulObjectCount == NULL) - return CKR_ARGUMENTS_BAD; + WOLFPKCS11_ENTER("C_FindObjects"); + #ifdef DEBUG_WOLFPKCS11 + if (wolfpkcs11_debugging) { + char paramStr[256]; + snprintf(paramStr, sizeof(paramStr), " hSession=%lu, ulMaxObjectCount=%lu", (unsigned long)hSession, (unsigned long)ulMaxObjectCount); + WOLFPKCS11_MSG(paramStr); + } + #endif + + if (!WP11_Library_IsInitialized()) { + rv = CKR_CRYPTOKI_NOT_INITIALIZED; + WOLFPKCS11_LEAVE("C_FindObjects", rv); + return rv; + } + if (WP11_Session_Get(hSession, &session) != 0) { + rv = CKR_SESSION_HANDLE_INVALID; + WOLFPKCS11_LEAVE("C_FindObjects", rv); + return rv; + } + if (phObject == NULL || pulObjectCount == NULL) { + rv = CKR_ARGUMENTS_BAD; + WOLFPKCS11_LEAVE("C_FindObjects", rv); + return rv; + } for (i = 0; i < (int)ulMaxObjectCount; i++) { if (WP11_Session_FindGet(session, &handle) == FIND_NO_MORE_E) @@ -1431,7 +1592,9 @@ CK_RV C_FindObjects(CK_SESSION_HANDLE hSession, } *pulObjectCount = i; - return CKR_OK; + rv = CKR_OK; + WOLFPKCS11_LEAVE("C_FindObjects", rv); + return rv; } /** @@ -1445,16 +1608,34 @@ CK_RV C_FindObjects(CK_SESSION_HANDLE hSession, */ CK_RV C_FindObjectsFinal(CK_SESSION_HANDLE hSession) { + CK_RV rv; WP11_Session* session; - if (!WP11_Library_IsInitialized()) - return CKR_CRYPTOKI_NOT_INITIALIZED; - if (WP11_Session_Get(hSession, &session) != 0) - return CKR_SESSION_HANDLE_INVALID; + WOLFPKCS11_ENTER("C_FindObjectsFinal"); + #ifdef DEBUG_WOLFPKCS11 + if (wolfpkcs11_debugging) { + char paramStr[256]; + snprintf(paramStr, sizeof(paramStr), " hSession=%lu", (unsigned long)hSession); + WOLFPKCS11_MSG(paramStr); + } + #endif + + if (!WP11_Library_IsInitialized()) { + rv = CKR_CRYPTOKI_NOT_INITIALIZED; + WOLFPKCS11_LEAVE("C_FindObjectsFinal", rv); + return rv; + } + if (WP11_Session_Get(hSession, &session) != 0) { + rv = CKR_SESSION_HANDLE_INVALID; + WOLFPKCS11_LEAVE("C_FindObjectsFinal", rv); + return rv; + } WP11_Session_FindFinal(session); - return CKR_OK; + rv = CKR_OK; + WOLFPKCS11_LEAVE("C_FindObjectsFinal", rv); + return rv; } @@ -1481,22 +1662,44 @@ CK_RV C_FindObjectsFinal(CK_SESSION_HANDLE hSession) CK_RV C_EncryptInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechanism, CK_OBJECT_HANDLE hKey) { + CK_RV rv; int ret; WP11_Session* session; WP11_Object* obj = NULL; CK_KEY_TYPE type; int init; - if (!WP11_Library_IsInitialized()) - return CKR_CRYPTOKI_NOT_INITIALIZED; - if (WP11_Session_Get(hSession, &session) != 0) - return CKR_SESSION_HANDLE_INVALID; - if (pMechanism == NULL) - return CKR_ARGUMENTS_BAD; + WOLFPKCS11_ENTER("C_EncryptInit"); + #ifdef DEBUG_WOLFPKCS11 + if (wolfpkcs11_debugging) { + char paramStr[256]; + snprintf(paramStr, sizeof(paramStr), " hSession=%lu, hKey=%lu", (unsigned long)hSession, (unsigned long)hKey); + WOLFPKCS11_MSG(paramStr); + } + #endif + + if (!WP11_Library_IsInitialized()) { + rv = CKR_CRYPTOKI_NOT_INITIALIZED; + WOLFPKCS11_LEAVE("C_EncryptInit", rv); + return rv; + } + if (WP11_Session_Get(hSession, &session) != 0) { + rv = CKR_SESSION_HANDLE_INVALID; + WOLFPKCS11_LEAVE("C_EncryptInit", rv); + return rv; + } + if (pMechanism == NULL) { + rv = CKR_ARGUMENTS_BAD; + WOLFPKCS11_LEAVE("C_EncryptInit", rv); + return rv; + } ret = WP11_Object_Find(session, hKey, &obj); - if (ret != 0) - return CKR_OBJECT_HANDLE_INVALID; + if (ret != 0) { + rv = CKR_OBJECT_HANDLE_INVALID; + WOLFPKCS11_LEAVE("C_EncryptInit", rv); + return rv; + } type = WP11_Object_GetType(obj); switch (pMechanism->mechanism) { @@ -1745,18 +1948,37 @@ CK_RV C_Encrypt(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pData, CK_ULONG ulDataLen, CK_BYTE_PTR pEncryptedData, CK_ULONG_PTR pulEncryptedDataLen) { + CK_RV rv; int ret; WP11_Session* session; WP11_Object* obj = NULL; word32 encDataLen; CK_MECHANISM_TYPE mechanism; - if (!WP11_Library_IsInitialized()) - return CKR_CRYPTOKI_NOT_INITIALIZED; - if (WP11_Session_Get(hSession, &session) != 0) - return CKR_SESSION_HANDLE_INVALID; - if (pData == NULL || pulEncryptedDataLen == NULL) - return CKR_ARGUMENTS_BAD; + WOLFPKCS11_ENTER("C_Encrypt"); + #ifdef DEBUG_WOLFPKCS11 + if (wolfpkcs11_debugging) { + char paramStr[256]; + snprintf(paramStr, sizeof(paramStr), " hSession=%lu, ulDataLen=%lu", (unsigned long)hSession, (unsigned long)ulDataLen); + WOLFPKCS11_MSG(paramStr); + } + #endif + + if (!WP11_Library_IsInitialized()) { + rv = CKR_CRYPTOKI_NOT_INITIALIZED; + WOLFPKCS11_LEAVE("C_Encrypt", rv); + return rv; + } + if (WP11_Session_Get(hSession, &session) != 0) { + rv = CKR_SESSION_HANDLE_INVALID; + WOLFPKCS11_LEAVE("C_Encrypt", rv); + return rv; + } + if (pData == NULL || pulEncryptedDataLen == NULL) { + rv = CKR_ARGUMENTS_BAD; + WOLFPKCS11_LEAVE("C_Encrypt", rv); + return rv; + } /* Key the key for the encryption operation. */ WP11_Session_GetObject(session, &obj); @@ -2068,13 +2290,33 @@ CK_RV C_EncryptUpdate(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pPart, WP11_Object* obj = NULL; word32 encPartLen; CK_MECHANISM_TYPE mechanism; + CK_RV rv; - if (!WP11_Library_IsInitialized()) - return CKR_CRYPTOKI_NOT_INITIALIZED; - if (WP11_Session_Get(hSession, &session) != 0) - return CKR_SESSION_HANDLE_INVALID; - if (pPart == NULL || pulEncryptedPartLen == NULL) - return CKR_ARGUMENTS_BAD; + WOLFPKCS11_ENTER("C_EncryptUpdate"); + #ifdef DEBUG_WOLFPKCS11 + if (wolfpkcs11_debugging) { + char paramStr[256]; + snprintf(paramStr, sizeof(paramStr), " hSession=%lu, ulPartLen=%lu", + (unsigned long)hSession, (unsigned long)ulPartLen); + WOLFPKCS11_MSG(paramStr); + } + #endif + + if (!WP11_Library_IsInitialized()) { + rv = CKR_CRYPTOKI_NOT_INITIALIZED; + WOLFPKCS11_LEAVE("C_EncryptUpdate", rv); + return rv; + } + if (WP11_Session_Get(hSession, &session) != 0) { + rv = CKR_SESSION_HANDLE_INVALID; + WOLFPKCS11_LEAVE("C_EncryptUpdate", rv); + return rv; + } + if (pPart == NULL || pulEncryptedPartLen == NULL) { + rv = CKR_ARGUMENTS_BAD; + WOLFPKCS11_LEAVE("C_EncryptUpdate", rv); + return rv; + } WP11_Session_GetObject(session, &obj); if (obj == NULL) @@ -2085,23 +2327,34 @@ CK_RV C_EncryptUpdate(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pPart, #ifndef NO_AES #ifdef HAVE_AES_CBC case CKM_AES_CBC: - if (!WP11_Session_IsOpInitialized(session, WP11_INIT_AES_CBC_ENC)) - return CKR_OPERATION_NOT_INITIALIZED; + if (!WP11_Session_IsOpInitialized(session, WP11_INIT_AES_CBC_ENC)) { + rv = CKR_OPERATION_NOT_INITIALIZED; + WOLFPKCS11_LEAVE("C_EncryptUpdate", rv); + return rv; + } encPartLen = (word32)ulPartLen + WP11_AesCbc_PartLen(session); encPartLen &= ~0xf; if (pEncryptedPart == NULL) { *pulEncryptedPartLen = encPartLen; - return CKR_OK; + rv = CKR_OK; + WOLFPKCS11_LEAVE("C_EncryptUpdate", rv); + return rv; + } + if (encPartLen > (word32)*pulEncryptedPartLen) { + rv = CKR_BUFFER_TOO_SMALL; + WOLFPKCS11_LEAVE("C_EncryptUpdate", rv); + return rv; } - if (encPartLen > (word32)*pulEncryptedPartLen) - return CKR_BUFFER_TOO_SMALL; ret = WP11_AesCbc_EncryptUpdate(pPart, (int)ulPartLen, pEncryptedPart, &encPartLen, session); - if (ret < 0) - return CKR_FUNCTION_FAILED; + if (ret < 0) { + rv = CKR_FUNCTION_FAILED; + WOLFPKCS11_LEAVE("C_EncryptUpdate", rv); + return rv; + } *pulEncryptedPartLen = encPartLen; break; case CKM_AES_CBC_PAD: @@ -2193,10 +2446,14 @@ CK_RV C_EncryptUpdate(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pPart, (void)ret; (void)ulPartLen; (void)pEncryptedPart; - return CKR_MECHANISM_INVALID; + rv = CKR_MECHANISM_INVALID; + WOLFPKCS11_LEAVE("C_EncryptUpdate", rv); + return rv; } - return CKR_OK; + rv = CKR_OK; + WOLFPKCS11_LEAVE("C_EncryptUpdate", rv); + return rv; } /** @@ -2227,9 +2484,23 @@ CK_RV C_EncryptFinal(CK_SESSION_HANDLE hSession, WP11_Object* obj = NULL; word32 encPartLen; CK_MECHANISM_TYPE mechanism; + CK_RV rv; - if (!WP11_Library_IsInitialized()) - return CKR_CRYPTOKI_NOT_INITIALIZED; + WOLFPKCS11_ENTER("C_EncryptFinal"); + #ifdef DEBUG_WOLFPKCS11 + if (wolfpkcs11_debugging) { + char paramStr[256]; + snprintf(paramStr, sizeof(paramStr), " hSession=%lu", + (unsigned long)hSession); + WOLFPKCS11_MSG(paramStr); + } + #endif + + if (!WP11_Library_IsInitialized()) { + rv = CKR_CRYPTOKI_NOT_INITIALIZED; + WOLFPKCS11_LEAVE("C_EncryptFinal", rv); + return rv; + } if (WP11_Session_Get(hSession, &session) != 0) return CKR_SESSION_HANDLE_INVALID; if (pulLastEncryptedPartLen == NULL) @@ -2375,9 +2646,23 @@ CK_RV C_DecryptInit(CK_SESSION_HANDLE hSession, WP11_Object* obj = NULL; CK_KEY_TYPE type; int init; + CK_RV rv; + + WOLFPKCS11_ENTER("C_DecryptInit"); + #ifdef DEBUG_WOLFPKCS11 + if (wolfpkcs11_debugging) { + char paramStr[256]; + snprintf(paramStr, sizeof(paramStr), " hSession=%lu, hKey=%lu", + (unsigned long)hSession, (unsigned long)hKey); + WOLFPKCS11_MSG(paramStr); + } + #endif - if (!WP11_Library_IsInitialized()) - return CKR_CRYPTOKI_NOT_INITIALIZED; + if (!WP11_Library_IsInitialized()) { + rv = CKR_CRYPTOKI_NOT_INITIALIZED; + WOLFPKCS11_LEAVE("C_DecryptInit", rv); + return rv; + } if (WP11_Session_Get(hSession, &session) != 0) return CKR_SESSION_HANDLE_INVALID; if (pMechanism == NULL) @@ -2633,9 +2918,23 @@ CK_RV C_Decrypt(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pEncryptedData, WP11_Object* obj = NULL; word32 decDataLen; CK_MECHANISM_TYPE mechanism; + CK_RV rv; + + WOLFPKCS11_ENTER("C_Decrypt"); + #ifdef DEBUG_WOLFPKCS11 + if (wolfpkcs11_debugging) { + char paramStr[256]; + snprintf(paramStr, sizeof(paramStr), " hSession=%lu, ulEncryptedDataLen=%lu", + (unsigned long)hSession, (unsigned long)ulEncryptedDataLen); + WOLFPKCS11_MSG(paramStr); + } + #endif - if (!WP11_Library_IsInitialized()) - return CKR_CRYPTOKI_NOT_INITIALIZED; + if (!WP11_Library_IsInitialized()) { + rv = CKR_CRYPTOKI_NOT_INITIALIZED; + WOLFPKCS11_LEAVE("C_Decrypt", rv); + return rv; + } if (WP11_Session_Get(hSession, &session) != 0) return CKR_SESSION_HANDLE_INVALID; if (pEncryptedData == NULL || pulDataLen == NULL) @@ -2935,9 +3234,23 @@ CK_RV C_DecryptUpdate(CK_SESSION_HANDLE hSession, WP11_Object* obj = NULL; word32 decPartLen; CK_MECHANISM_TYPE mechanism; + CK_RV rv; - if (!WP11_Library_IsInitialized()) - return CKR_CRYPTOKI_NOT_INITIALIZED; + WOLFPKCS11_ENTER("C_DecryptUpdate"); + #ifdef DEBUG_WOLFPKCS11 + if (wolfpkcs11_debugging) { + char paramStr[256]; + snprintf(paramStr, sizeof(paramStr), " hSession=%lu, ulEncryptedPartLen=%lu", + (unsigned long)hSession, (unsigned long)ulEncryptedPartLen); + WOLFPKCS11_MSG(paramStr); + } + #endif + + if (!WP11_Library_IsInitialized()) { + rv = CKR_CRYPTOKI_NOT_INITIALIZED; + WOLFPKCS11_LEAVE("C_DecryptUpdate", rv); + return rv; + } if (WP11_Session_Get(hSession, &session) != 0) return CKR_SESSION_HANDLE_INVALID; if (pEncryptedPart == NULL || pulPartLen == NULL) @@ -3094,9 +3407,23 @@ CK_RV C_DecryptFinal(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pLastPart, WP11_Object* obj = NULL; word32 decPartLen; CK_MECHANISM_TYPE mechanism; + CK_RV rv; - if (!WP11_Library_IsInitialized()) - return CKR_CRYPTOKI_NOT_INITIALIZED; + WOLFPKCS11_ENTER("C_DecryptFinal"); + #ifdef DEBUG_WOLFPKCS11 + if (wolfpkcs11_debugging) { + char paramStr[256]; + snprintf(paramStr, sizeof(paramStr), " hSession=%lu", + (unsigned long)hSession); + WOLFPKCS11_MSG(paramStr); + } + #endif + + if (!WP11_Library_IsInitialized()) { + rv = CKR_CRYPTOKI_NOT_INITIALIZED; + WOLFPKCS11_LEAVE("C_DecryptFinal", rv); + return rv; + } if (WP11_Session_Get(hSession, &session) != 0) return CKR_SESSION_HANDLE_INVALID; if (pulLastPartLen == NULL) @@ -3230,21 +3557,41 @@ CK_RV C_DecryptFinal(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pLastPart, CK_RV C_DigestInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechanism) { + CK_RV rv; int ret; int init; WP11_Session* session; - if (!WP11_Library_IsInitialized()) - return CKR_CRYPTOKI_NOT_INITIALIZED; - if (WP11_Session_Get(hSession, &session) != 0) - return CKR_SESSION_HANDLE_INVALID; - if (pMechanism == NULL) - return CKR_ARGUMENTS_BAD; + WOLFPKCS11_ENTER("C_DigestInit"); + #ifdef DEBUG_WOLFPKCS11 + if (wolfpkcs11_debugging) { + char paramStr[256]; + snprintf(paramStr, sizeof(paramStr), " hSession=%lu", (unsigned long)hSession); + WOLFPKCS11_MSG(paramStr); + } + #endif + + if (!WP11_Library_IsInitialized()) { + rv = CKR_CRYPTOKI_NOT_INITIALIZED; + WOLFPKCS11_LEAVE("C_DigestInit", rv); + return rv; + } + if (WP11_Session_Get(hSession, &session) != 0) { + rv = CKR_SESSION_HANDLE_INVALID; + WOLFPKCS11_LEAVE("C_DigestInit", rv); + return rv; + } + if (pMechanism == NULL) { + rv = CKR_ARGUMENTS_BAD; + WOLFPKCS11_LEAVE("C_DigestInit", rv); + return rv; + } if (pMechanism->pParameter != NULL || pMechanism->ulParameterLen != 0) { - - return CKR_MECHANISM_PARAM_INVALID; + rv = CKR_MECHANISM_PARAM_INVALID; + WOLFPKCS11_LEAVE("C_DigestInit", rv); + return rv; } init = WP11_INIT_DIGEST; ret = WP11_Digest_Init(pMechanism->mechanism, session); @@ -3254,7 +3601,9 @@ CK_RV C_DigestInit(CK_SESSION_HANDLE hSession, WP11_Session_SetOpInitialized(session, init); } - return ret; + rv = ret; + WOLFPKCS11_LEAVE("C_DigestInit", rv); + return rv; } /** @@ -3281,9 +3630,23 @@ CK_RV C_Digest(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pData, word32 hashLen; int ret; WP11_Session* session; + CK_RV rv; + + WOLFPKCS11_ENTER("C_Digest"); + #ifdef DEBUG_WOLFPKCS11 + if (wolfpkcs11_debugging) { + char paramStr[256]; + snprintf(paramStr, sizeof(paramStr), " hSession=%lu, ulDataLen=%lu", + (unsigned long)hSession, (unsigned long)ulDataLen); + WOLFPKCS11_MSG(paramStr); + } + #endif - if (!WP11_Library_IsInitialized()) - return CKR_CRYPTOKI_NOT_INITIALIZED; + if (!WP11_Library_IsInitialized()) { + rv = CKR_CRYPTOKI_NOT_INITIALIZED; + WOLFPKCS11_LEAVE("C_Digest", rv); + return rv; + } if (WP11_Session_Get(hSession, &session) != 0) return CKR_SESSION_HANDLE_INVALID; if (pData == NULL || ulDataLen == 0 || pulDigestLen == NULL) @@ -3315,9 +3678,23 @@ CK_RV C_DigestUpdate(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pPart, { int ret; WP11_Session* session; + CK_RV rv; + + WOLFPKCS11_ENTER("C_DigestUpdate"); + #ifdef DEBUG_WOLFPKCS11 + if (wolfpkcs11_debugging) { + char paramStr[256]; + snprintf(paramStr, sizeof(paramStr), " hSession=%lu, ulPartLen=%lu", + (unsigned long)hSession, (unsigned long)ulPartLen); + WOLFPKCS11_MSG(paramStr); + } + #endif - if (!WP11_Library_IsInitialized()) - return CKR_CRYPTOKI_NOT_INITIALIZED; + if (!WP11_Library_IsInitialized()) { + rv = CKR_CRYPTOKI_NOT_INITIALIZED; + WOLFPKCS11_LEAVE("C_DigestUpdate", rv); + return rv; + } if (WP11_Session_Get(hSession, &session) != 0) return CKR_SESSION_HANDLE_INVALID; if (pPart == NULL || ulPartLen == 0) @@ -3347,9 +3724,23 @@ CK_RV C_DigestKey(CK_SESSION_HANDLE hSession, CK_OBJECT_HANDLE hKey) int ret; WP11_Session* session; WP11_Object* obj = NULL; + CK_RV rv; + + WOLFPKCS11_ENTER("C_DigestKey"); + #ifdef DEBUG_WOLFPKCS11 + if (wolfpkcs11_debugging) { + char paramStr[256]; + snprintf(paramStr, sizeof(paramStr), " hSession=%lu, hKey=%lu", + (unsigned long)hSession, (unsigned long)hKey); + WOLFPKCS11_MSG(paramStr); + } + #endif - if (!WP11_Library_IsInitialized()) - return CKR_CRYPTOKI_NOT_INITIALIZED; + if (!WP11_Library_IsInitialized()) { + rv = CKR_CRYPTOKI_NOT_INITIALIZED; + WOLFPKCS11_LEAVE("C_DigestKey", rv); + return rv; + } if (WP11_Session_Get(hSession, &session) != 0) return CKR_SESSION_HANDLE_INVALID; @@ -3383,9 +3774,23 @@ CK_RV C_DigestFinal(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pDigest, int ret; word32 hashLen; WP11_Session* session; + CK_RV rv; + + WOLFPKCS11_ENTER("C_DigestFinal"); + #ifdef DEBUG_WOLFPKCS11 + if (wolfpkcs11_debugging) { + char paramStr[256]; + snprintf(paramStr, sizeof(paramStr), " hSession=%lu", + (unsigned long)hSession); + WOLFPKCS11_MSG(paramStr); + } + #endif - if (!WP11_Library_IsInitialized()) - return CKR_CRYPTOKI_NOT_INITIALIZED; + if (!WP11_Library_IsInitialized()) { + rv = CKR_CRYPTOKI_NOT_INITIALIZED; + WOLFPKCS11_LEAVE("C_DigestFinal", rv); + return rv; + } if (WP11_Session_Get(hSession, &session) != 0) return CKR_SESSION_HANDLE_INVALID; if (pulDigestLen == NULL) @@ -3461,9 +3866,23 @@ CK_RV C_SignInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechanism, WP11_Object* obj = NULL; CK_KEY_TYPE type; int init = 0; + CK_RV rv; + + WOLFPKCS11_ENTER("C_SignInit"); + #ifdef DEBUG_WOLFPKCS11 + if (wolfpkcs11_debugging) { + char paramStr[256]; + snprintf(paramStr, sizeof(paramStr), " hSession=%lu, hKey=%lu", + (unsigned long)hSession, (unsigned long)hKey); + WOLFPKCS11_MSG(paramStr); + } + #endif - if (!WP11_Library_IsInitialized()) - return CKR_CRYPTOKI_NOT_INITIALIZED; + if (!WP11_Library_IsInitialized()) { + rv = CKR_CRYPTOKI_NOT_INITIALIZED; + WOLFPKCS11_LEAVE("C_SignInit", rv); + return rv; + } if (WP11_Session_Get(hSession, &session) != 0) return CKR_SESSION_HANDLE_INVALID; if (pMechanism == NULL) @@ -3764,9 +4183,23 @@ CK_RV C_Sign(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pData, WP11_Object* obj = NULL; word32 sigLen; CK_MECHANISM_TYPE mechanism; + CK_RV rv; + + WOLFPKCS11_ENTER("C_Sign"); + #ifdef DEBUG_WOLFPKCS11 + if (wolfpkcs11_debugging) { + char paramStr[256]; + snprintf(paramStr, sizeof(paramStr), " hSession=%lu, ulDataLen=%lu", + (unsigned long)hSession, (unsigned long)ulDataLen); + WOLFPKCS11_MSG(paramStr); + } + #endif - if (!WP11_Library_IsInitialized()) - return CKR_CRYPTOKI_NOT_INITIALIZED; + if (!WP11_Library_IsInitialized()) { + rv = CKR_CRYPTOKI_NOT_INITIALIZED; + WOLFPKCS11_LEAVE("C_Sign", rv); + return rv; + } if (WP11_Session_Get(hSession, &session) != 0) return CKR_SESSION_HANDLE_INVALID; if (pData == NULL || pulSignatureLen == NULL) @@ -4080,9 +4513,23 @@ CK_RV C_SignUpdate(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pPart, WP11_Session* session; WP11_Object* obj = NULL; CK_MECHANISM_TYPE mechanism; + CK_RV rv; + + WOLFPKCS11_ENTER("C_SignUpdate"); + #ifdef DEBUG_WOLFPKCS11 + if (wolfpkcs11_debugging) { + char paramStr[256]; + snprintf(paramStr, sizeof(paramStr), " hSession=%lu, ulPartLen=%lu", + (unsigned long)hSession, (unsigned long)ulPartLen); + WOLFPKCS11_MSG(paramStr); + } + #endif - if (!WP11_Library_IsInitialized()) - return CKR_CRYPTOKI_NOT_INITIALIZED; + if (!WP11_Library_IsInitialized()) { + rv = CKR_CRYPTOKI_NOT_INITIALIZED; + WOLFPKCS11_LEAVE("C_SignUpdate", rv); + return rv; + } if (WP11_Session_Get(hSession, &session) != 0) return CKR_SESSION_HANDLE_INVALID; if (pPart == NULL) @@ -4193,9 +4640,23 @@ CK_RV C_SignFinal(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pSignature, WP11_Object* obj = NULL; CK_MECHANISM_TYPE mechanism; word32 sigLen; + CK_RV rv; + + WOLFPKCS11_ENTER("C_SignFinal"); + #ifdef DEBUG_WOLFPKCS11 + if (wolfpkcs11_debugging) { + char paramStr[256]; + snprintf(paramStr, sizeof(paramStr), " hSession=%lu", + (unsigned long)hSession); + WOLFPKCS11_MSG(paramStr); + } + #endif - if (!WP11_Library_IsInitialized()) - return CKR_CRYPTOKI_NOT_INITIALIZED; + if (!WP11_Library_IsInitialized()) { + rv = CKR_CRYPTOKI_NOT_INITIALIZED; + WOLFPKCS11_LEAVE("C_SignFinal", rv); + return rv; + } if (WP11_Session_Get(hSession, &session) != 0) return CKR_SESSION_HANDLE_INVALID; if (pulSignatureLen == NULL) @@ -4325,19 +4786,44 @@ CK_RV C_SignRecoverInit(CK_SESSION_HANDLE hSession, int ret; WP11_Session* session; WP11_Object* obj; + CK_RV rv; - if (!WP11_Library_IsInitialized()) - return CKR_CRYPTOKI_NOT_INITIALIZED; - if (WP11_Session_Get(hSession, &session) != 0) - return CKR_SESSION_HANDLE_INVALID; - if (pMechanism == NULL) - return CKR_ARGUMENTS_BAD; + WOLFPKCS11_ENTER("C_SignRecoverInit"); + #ifdef DEBUG_WOLFPKCS11 + if (wolfpkcs11_debugging) { + char paramStr[256]; + snprintf(paramStr, sizeof(paramStr), " hSession=%lu, hKey=%lu", + (unsigned long)hSession, (unsigned long)hKey); + WOLFPKCS11_MSG(paramStr); + } + #endif + + if (!WP11_Library_IsInitialized()) { + rv = CKR_CRYPTOKI_NOT_INITIALIZED; + WOLFPKCS11_LEAVE("C_SignRecoverInit", rv); + return rv; + } + if (WP11_Session_Get(hSession, &session) != 0) { + rv = CKR_SESSION_HANDLE_INVALID; + WOLFPKCS11_LEAVE("C_SignRecoverInit", rv); + return rv; + } + if (pMechanism == NULL) { + rv = CKR_ARGUMENTS_BAD; + WOLFPKCS11_LEAVE("C_SignRecoverInit", rv); + return rv; + } ret = WP11_Object_Find(session, hKey, &obj); - if (ret != 0) - return CKR_OBJECT_HANDLE_INVALID; + if (ret != 0) { + rv = CKR_OBJECT_HANDLE_INVALID; + WOLFPKCS11_LEAVE("C_SignRecoverInit", rv); + return rv; + } - return CKR_MECHANISM_INVALID; + rv = CKR_MECHANISM_INVALID; + WOLFPKCS11_LEAVE("C_SignRecoverInit", rv); + return rv; } /** @@ -4362,17 +4848,39 @@ CK_RV C_SignRecover(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pData, CK_ULONG_PTR pulSignatureLen) { WP11_Session* session; + CK_RV rv; - if (!WP11_Library_IsInitialized()) - return CKR_CRYPTOKI_NOT_INITIALIZED; - if (WP11_Session_Get(hSession, &session) != 0) - return CKR_SESSION_HANDLE_INVALID; - if (pData == NULL || ulDataLen == 0 || pulSignatureLen == NULL) - return CKR_ARGUMENTS_BAD; + WOLFPKCS11_ENTER("C_SignRecover"); + #ifdef DEBUG_WOLFPKCS11 + if (wolfpkcs11_debugging) { + char paramStr[256]; + snprintf(paramStr, sizeof(paramStr), " hSession=%lu, ulDataLen=%lu", + (unsigned long)hSession, (unsigned long)ulDataLen); + WOLFPKCS11_MSG(paramStr); + } + #endif + + if (!WP11_Library_IsInitialized()) { + rv = CKR_CRYPTOKI_NOT_INITIALIZED; + WOLFPKCS11_LEAVE("C_SignRecover", rv); + return rv; + } + if (WP11_Session_Get(hSession, &session) != 0) { + rv = CKR_SESSION_HANDLE_INVALID; + WOLFPKCS11_LEAVE("C_SignRecover", rv); + return rv; + } + if (pData == NULL || ulDataLen == 0 || pulSignatureLen == NULL) { + rv = CKR_ARGUMENTS_BAD; + WOLFPKCS11_LEAVE("C_SignRecover", rv); + return rv; + } (void)pSignature; - return CKR_OPERATION_NOT_INITIALIZED; + rv = CKR_OPERATION_NOT_INITIALIZED; + WOLFPKCS11_LEAVE("C_SignRecover", rv); + return rv; } /** @@ -4402,17 +4910,40 @@ CK_RV C_VerifyInit(CK_SESSION_HANDLE hSession, WP11_Object* obj = NULL; CK_KEY_TYPE type; int init = 0; + CK_RV rv; - if (!WP11_Library_IsInitialized()) - return CKR_CRYPTOKI_NOT_INITIALIZED; - if (WP11_Session_Get(hSession, &session) != 0) - return CKR_SESSION_HANDLE_INVALID; - if (pMechanism == NULL) - return CKR_ARGUMENTS_BAD; + WOLFPKCS11_ENTER("C_VerifyInit"); + #ifdef DEBUG_WOLFPKCS11 + if (wolfpkcs11_debugging) { + char paramStr[256]; + snprintf(paramStr, sizeof(paramStr), " hSession=%lu, hKey=%lu", + (unsigned long)hSession, (unsigned long)hKey); + WOLFPKCS11_MSG(paramStr); + } + #endif + + if (!WP11_Library_IsInitialized()) { + rv = CKR_CRYPTOKI_NOT_INITIALIZED; + WOLFPKCS11_LEAVE("C_VerifyInit", rv); + return rv; + } + if (WP11_Session_Get(hSession, &session) != 0) { + rv = CKR_SESSION_HANDLE_INVALID; + WOLFPKCS11_LEAVE("C_VerifyInit", rv); + return rv; + } + if (pMechanism == NULL) { + rv = CKR_ARGUMENTS_BAD; + WOLFPKCS11_LEAVE("C_VerifyInit", rv); + return rv; + } ret = WP11_Object_Find(session, hKey, &obj); - if (ret != 0) - return CKR_OBJECT_HANDLE_INVALID; + if (ret != 0) { + rv = CKR_OBJECT_HANDLE_INVALID; + WOLFPKCS11_LEAVE("C_VerifyInit", rv); + return rv; + } type = WP11_Object_GetType(obj); switch (pMechanism->mechanism) { @@ -4686,13 +5217,33 @@ CK_RV C_Verify(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pData, WP11_Session* session = NULL; WP11_Object* obj = NULL; CK_MECHANISM_TYPE mechanism = 0; + CK_RV rv; - if (!WP11_Library_IsInitialized()) - return CKR_CRYPTOKI_NOT_INITIALIZED; - if (WP11_Session_Get(hSession, &session) != 0) - return CKR_SESSION_HANDLE_INVALID; - if (pData == NULL || pSignature == NULL) - return CKR_ARGUMENTS_BAD; + WOLFPKCS11_ENTER("C_Verify"); + #ifdef DEBUG_WOLFPKCS11 + if (wolfpkcs11_debugging) { + char paramStr[256]; + snprintf(paramStr, sizeof(paramStr), " hSession=%lu, ulDataLen=%lu, ulSignatureLen=%lu", + (unsigned long)hSession, (unsigned long)ulDataLen, (unsigned long)ulSignatureLen); + WOLFPKCS11_MSG(paramStr); + } + #endif + + if (!WP11_Library_IsInitialized()) { + rv = CKR_CRYPTOKI_NOT_INITIALIZED; + WOLFPKCS11_LEAVE("C_Verify", rv); + return rv; + } + if (WP11_Session_Get(hSession, &session) != 0) { + rv = CKR_SESSION_HANDLE_INVALID; + WOLFPKCS11_LEAVE("C_Verify", rv); + return rv; + } + if (pData == NULL || pSignature == NULL) { + rv = CKR_ARGUMENTS_BAD; + WOLFPKCS11_LEAVE("C_Verify", rv); + return rv; + } WP11_Session_GetObject(session, &obj); if (obj == NULL) @@ -4944,13 +5495,33 @@ CK_RV C_VerifyUpdate(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pPart, WP11_Session* session; WP11_Object* obj = NULL; CK_MECHANISM_TYPE mechanism; + CK_RV rv; - if (!WP11_Library_IsInitialized()) - return CKR_CRYPTOKI_NOT_INITIALIZED; - if (WP11_Session_Get(hSession, &session) != 0) - return CKR_SESSION_HANDLE_INVALID; - if (pPart == NULL) - return CKR_ARGUMENTS_BAD; + WOLFPKCS11_ENTER("C_VerifyUpdate"); + #ifdef DEBUG_WOLFPKCS11 + if (wolfpkcs11_debugging) { + char paramStr[256]; + snprintf(paramStr, sizeof(paramStr), " hSession=%lu, ulPartLen=%lu", + (unsigned long)hSession, (unsigned long)ulPartLen); + WOLFPKCS11_MSG(paramStr); + } + #endif + + if (!WP11_Library_IsInitialized()) { + rv = CKR_CRYPTOKI_NOT_INITIALIZED; + WOLFPKCS11_LEAVE("C_VerifyUpdate", rv); + return rv; + } + if (WP11_Session_Get(hSession, &session) != 0) { + rv = CKR_SESSION_HANDLE_INVALID; + WOLFPKCS11_LEAVE("C_VerifyUpdate", rv); + return rv; + } + if (pPart == NULL) { + rv = CKR_ARGUMENTS_BAD; + WOLFPKCS11_LEAVE("C_VerifyUpdate", rv); + return rv; + } WP11_Session_GetObject(session, &obj); if (obj == NULL) @@ -5045,13 +5616,33 @@ CK_RV C_VerifyFinal(CK_SESSION_HANDLE hSession, WP11_Session* session = NULL; WP11_Object* obj = NULL; CK_MECHANISM_TYPE mechanism = 0; + CK_RV rv; - if (!WP11_Library_IsInitialized()) - return CKR_CRYPTOKI_NOT_INITIALIZED; - if (WP11_Session_Get(hSession, &session) != 0) - return CKR_SESSION_HANDLE_INVALID; - if (pSignature == NULL) - return CKR_ARGUMENTS_BAD; + WOLFPKCS11_ENTER("C_VerifyFinal"); + #ifdef DEBUG_WOLFPKCS11 + if (wolfpkcs11_debugging) { + char paramStr[256]; + snprintf(paramStr, sizeof(paramStr), " hSession=%lu, ulSignatureLen=%lu", + (unsigned long)hSession, (unsigned long)ulSignatureLen); + WOLFPKCS11_MSG(paramStr); + } + #endif + + if (!WP11_Library_IsInitialized()) { + rv = CKR_CRYPTOKI_NOT_INITIALIZED; + WOLFPKCS11_LEAVE("C_VerifyFinal", rv); + return rv; + } + if (WP11_Session_Get(hSession, &session) != 0) { + rv = CKR_SESSION_HANDLE_INVALID; + WOLFPKCS11_LEAVE("C_VerifyFinal", rv); + return rv; + } + if (pSignature == NULL) { + rv = CKR_ARGUMENTS_BAD; + WOLFPKCS11_LEAVE("C_VerifyFinal", rv); + return rv; + } WP11_Session_GetObject(session, &obj); if (obj == NULL) @@ -5149,15 +5740,38 @@ CK_RV C_VerifyRecoverInit(CK_SESSION_HANDLE hSession, WP11_Object* obj; CK_BBOOL getVar; CK_ULONG getVarLen = sizeof(CK_BBOOL); + CK_RV rv; - if (!WP11_Library_IsInitialized()) - return CKR_CRYPTOKI_NOT_INITIALIZED; - if (WP11_Session_Get(hSession, &session) != 0) - return CKR_SESSION_HANDLE_INVALID; - if (pMechanism == NULL) - return CKR_ARGUMENTS_BAD; - if (hKey == 0) - return CKR_OBJECT_HANDLE_INVALID; + WOLFPKCS11_ENTER("C_VerifyRecoverInit"); + #ifdef DEBUG_WOLFPKCS11 + if (wolfpkcs11_debugging) { + char paramStr[256]; + snprintf(paramStr, sizeof(paramStr), " hSession=%lu, hKey=%lu", + (unsigned long)hSession, (unsigned long)hKey); + WOLFPKCS11_MSG(paramStr); + } + #endif + + if (!WP11_Library_IsInitialized()) { + rv = CKR_CRYPTOKI_NOT_INITIALIZED; + WOLFPKCS11_LEAVE("C_VerifyRecoverInit", rv); + return rv; + } + if (WP11_Session_Get(hSession, &session) != 0) { + rv = CKR_SESSION_HANDLE_INVALID; + WOLFPKCS11_LEAVE("C_VerifyRecoverInit", rv); + return rv; + } + if (pMechanism == NULL) { + rv = CKR_ARGUMENTS_BAD; + WOLFPKCS11_LEAVE("C_VerifyRecoverInit", rv); + return rv; + } + if (hKey == 0) { + rv = CKR_OBJECT_HANDLE_INVALID; + WOLFPKCS11_LEAVE("C_VerifyRecoverInit", rv); + return rv; + } switch(pMechanism->mechanism) { case CKM_RSA_PKCS: @@ -5229,13 +5843,33 @@ CK_RV C_VerifyRecover(CK_SESSION_HANDLE hSession, word32 decDataLen; CK_MECHANISM_TYPE mechanism; #endif + CK_RV rv; - if (!WP11_Library_IsInitialized()) - return CKR_CRYPTOKI_NOT_INITIALIZED; - if (WP11_Session_Get(hSession, &session) != 0) - return CKR_SESSION_HANDLE_INVALID; - if (pSignature == NULL || ulSignatureLen == 0 || pulDataLen == NULL) - return CKR_ARGUMENTS_BAD; + WOLFPKCS11_ENTER("C_VerifyRecover"); + #ifdef DEBUG_WOLFPKCS11 + if (wolfpkcs11_debugging) { + char paramStr[256]; + snprintf(paramStr, sizeof(paramStr), " hSession=%lu, ulSignatureLen=%lu", + (unsigned long)hSession, (unsigned long)ulSignatureLen); + WOLFPKCS11_MSG(paramStr); + } + #endif + + if (!WP11_Library_IsInitialized()) { + rv = CKR_CRYPTOKI_NOT_INITIALIZED; + WOLFPKCS11_LEAVE("C_VerifyRecover", rv); + return rv; + } + if (WP11_Session_Get(hSession, &session) != 0) { + rv = CKR_SESSION_HANDLE_INVALID; + WOLFPKCS11_LEAVE("C_VerifyRecover", rv); + return rv; + } + if (pSignature == NULL || ulSignatureLen == 0 || pulDataLen == NULL) { + rv = CKR_ARGUMENTS_BAD; + WOLFPKCS11_LEAVE("C_VerifyRecover", rv); + return rv; + } #ifdef NO_RSA (void) pData; @@ -5307,17 +5941,39 @@ CK_RV C_DigestEncryptUpdate(CK_SESSION_HANDLE hSession, CK_ULONG_PTR pulEncryptedPartLen) { WP11_Session* session; + CK_RV rv; - if (!WP11_Library_IsInitialized()) - return CKR_CRYPTOKI_NOT_INITIALIZED; - if (WP11_Session_Get(hSession, &session) != 0) - return CKR_SESSION_HANDLE_INVALID; - if (pPart == NULL || ulPartLen == 0 || pulEncryptedPartLen == NULL) - return CKR_ARGUMENTS_BAD; + WOLFPKCS11_ENTER("C_DigestEncryptUpdate"); + #ifdef DEBUG_WOLFPKCS11 + if (wolfpkcs11_debugging) { + char paramStr[256]; + snprintf(paramStr, sizeof(paramStr), " hSession=%lu, ulPartLen=%lu", + (unsigned long)hSession, (unsigned long)ulPartLen); + WOLFPKCS11_MSG(paramStr); + } + #endif + + if (!WP11_Library_IsInitialized()) { + rv = CKR_CRYPTOKI_NOT_INITIALIZED; + WOLFPKCS11_LEAVE("C_DigestEncryptUpdate", rv); + return rv; + } + if (WP11_Session_Get(hSession, &session) != 0) { + rv = CKR_SESSION_HANDLE_INVALID; + WOLFPKCS11_LEAVE("C_DigestEncryptUpdate", rv); + return rv; + } + if (pPart == NULL || ulPartLen == 0 || pulEncryptedPartLen == NULL) { + rv = CKR_ARGUMENTS_BAD; + WOLFPKCS11_LEAVE("C_DigestEncryptUpdate", rv); + return rv; + } (void)pEncryptedPart; - return CKR_OPERATION_NOT_INITIALIZED; + rv = CKR_OPERATION_NOT_INITIALIZED; + WOLFPKCS11_LEAVE("C_DigestEncryptUpdate", rv); + return rv; } /** @@ -5343,19 +5999,40 @@ CK_RV C_DecryptDigestUpdate(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pPart, CK_ULONG_PTR pulPartLen) { WP11_Session* session; + CK_RV rv; - if (!WP11_Library_IsInitialized()) - return CKR_CRYPTOKI_NOT_INITIALIZED; - if (WP11_Session_Get(hSession, &session) != 0) - return CKR_SESSION_HANDLE_INVALID; + WOLFPKCS11_ENTER("C_DecryptDigestUpdate"); + #ifdef DEBUG_WOLFPKCS11 + if (wolfpkcs11_debugging) { + char paramStr[256]; + snprintf(paramStr, sizeof(paramStr), " hSession=%lu, ulEncryptedPartLen=%lu", + (unsigned long)hSession, (unsigned long)ulEncryptedPartLen); + WOLFPKCS11_MSG(paramStr); + } + #endif + + if (!WP11_Library_IsInitialized()) { + rv = CKR_CRYPTOKI_NOT_INITIALIZED; + WOLFPKCS11_LEAVE("C_DecryptDigestUpdate", rv); + return rv; + } + if (WP11_Session_Get(hSession, &session) != 0) { + rv = CKR_SESSION_HANDLE_INVALID; + WOLFPKCS11_LEAVE("C_DecryptDigestUpdate", rv); + return rv; + } if (pEncryptedPart == NULL || ulEncryptedPartLen == 0 || pulPartLen == NULL) { - return CKR_ARGUMENTS_BAD; + rv = CKR_ARGUMENTS_BAD; + WOLFPKCS11_LEAVE("C_DecryptDigestUpdate", rv); + return rv; } (void)pPart; - return CKR_OPERATION_NOT_INITIALIZED; + rv = CKR_OPERATION_NOT_INITIALIZED; + WOLFPKCS11_LEAVE("C_DecryptDigestUpdate", rv); + return rv; } /** @@ -5382,17 +6059,39 @@ CK_RV C_SignEncryptUpdate(CK_SESSION_HANDLE hSession, CK_ULONG_PTR pulEncryptedPartLen) { WP11_Session* session; + CK_RV rv; - if (!WP11_Library_IsInitialized()) - return CKR_CRYPTOKI_NOT_INITIALIZED; - if (WP11_Session_Get(hSession, &session) != 0) - return CKR_SESSION_HANDLE_INVALID; - if (pPart == NULL || ulPartLen == 0 || pulEncryptedPartLen == NULL) - return CKR_ARGUMENTS_BAD; + WOLFPKCS11_ENTER("C_SignEncryptUpdate"); + #ifdef DEBUG_WOLFPKCS11 + if (wolfpkcs11_debugging) { + char paramStr[256]; + snprintf(paramStr, sizeof(paramStr), " hSession=%lu, ulPartLen=%lu", + (unsigned long)hSession, (unsigned long)ulPartLen); + WOLFPKCS11_MSG(paramStr); + } + #endif + + if (!WP11_Library_IsInitialized()) { + rv = CKR_CRYPTOKI_NOT_INITIALIZED; + WOLFPKCS11_LEAVE("C_SignEncryptUpdate", rv); + return rv; + } + if (WP11_Session_Get(hSession, &session) != 0) { + rv = CKR_SESSION_HANDLE_INVALID; + WOLFPKCS11_LEAVE("C_SignEncryptUpdate", rv); + return rv; + } + if (pPart == NULL || ulPartLen == 0 || pulEncryptedPartLen == NULL) { + rv = CKR_ARGUMENTS_BAD; + WOLFPKCS11_LEAVE("C_SignEncryptUpdate", rv); + return rv; + } (void)pEncryptedPart; - return CKR_OPERATION_NOT_INITIALIZED; + rv = CKR_OPERATION_NOT_INITIALIZED; + WOLFPKCS11_LEAVE("C_SignEncryptUpdate", rv); + return rv; } /** @@ -5418,19 +6117,40 @@ CK_RV C_DecryptVerifyUpdate(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pPart, CK_ULONG_PTR pulPartLen) { WP11_Session* session; + CK_RV rv; - if (!WP11_Library_IsInitialized()) - return CKR_CRYPTOKI_NOT_INITIALIZED; - if (WP11_Session_Get(hSession, &session) != 0) - return CKR_SESSION_HANDLE_INVALID; + WOLFPKCS11_ENTER("C_DecryptVerifyUpdate"); + #ifdef DEBUG_WOLFPKCS11 + if (wolfpkcs11_debugging) { + char paramStr[256]; + snprintf(paramStr, sizeof(paramStr), " hSession=%lu, ulEncryptedPartLen=%lu", + (unsigned long)hSession, (unsigned long)ulEncryptedPartLen); + WOLFPKCS11_MSG(paramStr); + } + #endif + + if (!WP11_Library_IsInitialized()) { + rv = CKR_CRYPTOKI_NOT_INITIALIZED; + WOLFPKCS11_LEAVE("C_DecryptVerifyUpdate", rv); + return rv; + } + if (WP11_Session_Get(hSession, &session) != 0) { + rv = CKR_SESSION_HANDLE_INVALID; + WOLFPKCS11_LEAVE("C_DecryptVerifyUpdate", rv); + return rv; + } if (pEncryptedPart == NULL || ulEncryptedPartLen == 0 || pulPartLen == NULL) { - return CKR_ARGUMENTS_BAD; + rv = CKR_ARGUMENTS_BAD; + WOLFPKCS11_LEAVE("C_DecryptVerifyUpdate", rv); + return rv; } (void)pPart; - return CKR_OPERATION_NOT_INITIALIZED; + rv = CKR_OPERATION_NOT_INITIALIZED; + WOLFPKCS11_LEAVE("C_DecryptVerifyUpdate", rv); + return rv; } /** @@ -5467,12 +6187,31 @@ CK_RV C_GenerateKey(CK_SESSION_HANDLE hSession, CK_ULONG getVarLen = sizeof(CK_BBOOL); CK_KEY_TYPE keyType; - if (!WP11_Library_IsInitialized()) - return CKR_CRYPTOKI_NOT_INITIALIZED; - if (WP11_Session_Get(hSession, &session) != 0) - return CKR_SESSION_HANDLE_INVALID; - if (pMechanism == NULL || pTemplate == NULL || phKey == NULL) - return CKR_ARGUMENTS_BAD; + WOLFPKCS11_ENTER("C_GenerateKey"); + #ifdef DEBUG_WOLFPKCS11 + if (wolfpkcs11_debugging) { + char paramStr[256]; + snprintf(paramStr, sizeof(paramStr), " hSession=%lu, ulCount=%lu", + (unsigned long)hSession, (unsigned long)ulCount); + WOLFPKCS11_MSG(paramStr); + } + #endif + + if (!WP11_Library_IsInitialized()) { + rv = CKR_CRYPTOKI_NOT_INITIALIZED; + WOLFPKCS11_LEAVE("C_GenerateKey", rv); + return rv; + } + if (WP11_Session_Get(hSession, &session) != 0) { + rv = CKR_SESSION_HANDLE_INVALID; + WOLFPKCS11_LEAVE("C_GenerateKey", rv); + return rv; + } + if (pMechanism == NULL || pTemplate == NULL || phKey == NULL) { + rv = CKR_ARGUMENTS_BAD; + WOLFPKCS11_LEAVE("C_GenerateKey", rv); + return rv; + } switch (pMechanism->mechanism) { #ifndef NO_AES @@ -5593,14 +6332,32 @@ CK_RV C_GenerateKeyPair(CK_SESSION_HANDLE hSession, WP11_Object* pub = NULL; WP11_Object* priv = NULL; - if (!WP11_Library_IsInitialized()) - return CKR_CRYPTOKI_NOT_INITIALIZED; - if (WP11_Session_Get(hSession, &session) != 0) - return CKR_SESSION_HANDLE_INVALID; + WOLFPKCS11_ENTER("C_GenerateKeyPair"); + #ifdef DEBUG_WOLFPKCS11 + if (wolfpkcs11_debugging) { + char paramStr[256]; + snprintf(paramStr, sizeof(paramStr), " hSession=%lu, ulPublicKeyAttributeCount=%lu, ulPrivateKeyAttributeCount=%lu", + (unsigned long)hSession, (unsigned long)ulPublicKeyAttributeCount, (unsigned long)ulPrivateKeyAttributeCount); + WOLFPKCS11_MSG(paramStr); + } + #endif + + if (!WP11_Library_IsInitialized()) { + rv = CKR_CRYPTOKI_NOT_INITIALIZED; + WOLFPKCS11_LEAVE("C_GenerateKeyPair", rv); + return rv; + } + if (WP11_Session_Get(hSession, &session) != 0) { + rv = CKR_SESSION_HANDLE_INVALID; + WOLFPKCS11_LEAVE("C_GenerateKeyPair", rv); + return rv; + } if (pMechanism == NULL || pPublicKeyTemplate == NULL || pPrivateKeyTemplate == NULL || phPublicKey == NULL || phPrivateKey == NULL) { - return CKR_ARGUMENTS_BAD; + rv = CKR_ARGUMENTS_BAD; + WOLFPKCS11_LEAVE("C_GenerateKeyPair", rv); + return rv; } switch (pMechanism->mechanism) { @@ -5760,12 +6517,31 @@ CK_RV C_WrapKey(CK_SESSION_HANDLE hSession, word32 serialSize = 0; byte* serialBuff = NULL; - if (!WP11_Library_IsInitialized()) - return CKR_CRYPTOKI_NOT_INITIALIZED; - if (WP11_Session_Get(hSession, &session) != 0) - return CKR_SESSION_HANDLE_INVALID; - if (pMechanism == NULL || pulWrappedKeyLen == NULL) - return CKR_ARGUMENTS_BAD; + WOLFPKCS11_ENTER("C_WrapKey"); + #ifdef DEBUG_WOLFPKCS11 + if (wolfpkcs11_debugging) { + char paramStr[256]; + snprintf(paramStr, sizeof(paramStr), " hSession=%lu, hWrappingKey=%lu, hKey=%lu", + (unsigned long)hSession, (unsigned long)hWrappingKey, (unsigned long)hKey); + WOLFPKCS11_MSG(paramStr); + } + #endif + + if (!WP11_Library_IsInitialized()) { + rv = CKR_CRYPTOKI_NOT_INITIALIZED; + WOLFPKCS11_LEAVE("C_WrapKey", rv); + return rv; + } + if (WP11_Session_Get(hSession, &session) != 0) { + rv = CKR_SESSION_HANDLE_INVALID; + WOLFPKCS11_LEAVE("C_WrapKey", rv); + return rv; + } + if (pMechanism == NULL || pulWrappedKeyLen == NULL) { + rv = CKR_ARGUMENTS_BAD; + WOLFPKCS11_LEAVE("C_WrapKey", rv); + return rv; + } if (! WP11_Session_IsRW(session)) return CKR_SESSION_READ_ONLY; @@ -5914,17 +6690,38 @@ CK_RV C_UnwrapKey(CK_SESSION_HANDLE hSession, byte* workBuffer = NULL; CK_ULONG ulUnwrappedLen = ulWrappedKeyLen; - if (!WP11_Library_IsInitialized()) - return CKR_CRYPTOKI_NOT_INITIALIZED; - if (WP11_Session_Get(hSession, &session) != 0) - return CKR_SESSION_HANDLE_INVALID; + WOLFPKCS11_ENTER("C_UnwrapKey"); + #ifdef DEBUG_WOLFPKCS11 + if (wolfpkcs11_debugging) { + char paramStr[256]; + snprintf(paramStr, sizeof(paramStr), " hSession=%lu, hUnwrappingKey=%lu, ulWrappedKeyLen=%lu, ulAttributeCount=%lu", + (unsigned long)hSession, (unsigned long)hUnwrappingKey, (unsigned long)ulWrappedKeyLen, (unsigned long)ulAttributeCount); + WOLFPKCS11_MSG(paramStr); + } + #endif - if (!WP11_Session_IsRW(session)) - return CKR_SESSION_READ_ONLY; + if (!WP11_Library_IsInitialized()) { + rv = CKR_CRYPTOKI_NOT_INITIALIZED; + WOLFPKCS11_LEAVE("C_UnwrapKey", rv); + return rv; + } + if (WP11_Session_Get(hSession, &session) != 0) { + rv = CKR_SESSION_HANDLE_INVALID; + WOLFPKCS11_LEAVE("C_UnwrapKey", rv); + return rv; + } + + if (!WP11_Session_IsRW(session)) { + rv = CKR_SESSION_READ_ONLY; + WOLFPKCS11_LEAVE("C_UnwrapKey", rv); + return rv; + } if (pMechanism == NULL || pWrappedKey == NULL || ulWrappedKeyLen == 0 || pTemplate == NULL || phKey == NULL) { - return CKR_ARGUMENTS_BAD; + rv = CKR_ARGUMENTS_BAD; + WOLFPKCS11_LEAVE("C_UnwrapKey", rv); + return rv; } *phKey = CK_INVALID_HANDLE; @@ -6263,16 +7060,38 @@ CK_RV C_DeriveKey(CK_SESSION_HANDLE hSession, CK_ULONG secretKeyLen[2] = { 0, 0 }; #endif - if (!WP11_Library_IsInitialized()) - return CKR_CRYPTOKI_NOT_INITIALIZED; - if (WP11_Session_Get(hSession, &session) != 0) - return CKR_SESSION_HANDLE_INVALID; - if (pMechanism == NULL || pTemplate == NULL) - return CKR_ARGUMENTS_BAD; + WOLFPKCS11_ENTER("C_DeriveKey"); + #ifdef DEBUG_WOLFPKCS11 + if (wolfpkcs11_debugging) { + char paramStr[256]; + snprintf(paramStr, sizeof(paramStr), " hSession=%lu, hBaseKey=%lu, ulAttributeCount=%lu", + (unsigned long)hSession, (unsigned long)hBaseKey, (unsigned long)ulAttributeCount); + WOLFPKCS11_MSG(paramStr); + } + #endif + + if (!WP11_Library_IsInitialized()) { + rv = CKR_CRYPTOKI_NOT_INITIALIZED; + WOLFPKCS11_LEAVE("C_DeriveKey", rv); + return rv; + } + if (WP11_Session_Get(hSession, &session) != 0) { + rv = CKR_SESSION_HANDLE_INVALID; + WOLFPKCS11_LEAVE("C_DeriveKey", rv); + return rv; + } + if (pMechanism == NULL || pTemplate == NULL) { + rv = CKR_ARGUMENTS_BAD; + WOLFPKCS11_LEAVE("C_DeriveKey", rv); + return rv; + } /* phKey can be NULL for CKM_TLS12_KEY_AND_MAC_DERIVE as it is ignored */ if ((phKey == NULL) && - (pMechanism->mechanism != CKM_TLS12_KEY_AND_MAC_DERIVE)) - return CKR_ARGUMENTS_BAD; + (pMechanism->mechanism != CKM_TLS12_KEY_AND_MAC_DERIVE)) { + rv = CKR_ARGUMENTS_BAD; + WOLFPKCS11_LEAVE("C_DeriveKey", rv); + return rv; + } ret = WP11_Object_Find(session, hBaseKey, &obj); if (ret != 0) @@ -6564,22 +7383,50 @@ CK_RV C_SeedRandom(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pSeed, int ret; WP11_Session* session; WP11_Slot* slot; + CK_RV rv; - if (!WP11_Library_IsInitialized()) - return CKR_CRYPTOKI_NOT_INITIALIZED; - if (WP11_Session_Get(hSession, &session) != 0) - return CKR_SESSION_HANDLE_INVALID; - if (pSeed == NULL) - return CKR_ARGUMENTS_BAD; + WOLFPKCS11_ENTER("C_SeedRandom"); + #ifdef DEBUG_WOLFPKCS11 + if (wolfpkcs11_debugging) { + char paramStr[256]; + snprintf(paramStr, sizeof(paramStr), " hSession=%lu, ulSeedLen=%lu", + (unsigned long)hSession, (unsigned long)ulSeedLen); + WOLFPKCS11_MSG(paramStr); + } + #endif + + if (!WP11_Library_IsInitialized()) { + rv = CKR_CRYPTOKI_NOT_INITIALIZED; + WOLFPKCS11_LEAVE("C_SeedRandom", rv); + return rv; + } + if (WP11_Session_Get(hSession, &session) != 0) { + rv = CKR_SESSION_HANDLE_INVALID; + WOLFPKCS11_LEAVE("C_SeedRandom", rv); + return rv; + } + if (pSeed == NULL) { + rv = CKR_ARGUMENTS_BAD; + WOLFPKCS11_LEAVE("C_SeedRandom", rv); + return rv; + } slot = WP11_Session_GetSlot(session); ret = WP11_Slot_SeedRandom(slot, pSeed, (int)ulSeedLen); - if (ret == MEMORY_E) - return CKR_DEVICE_MEMORY; - if (ret != 0) - return CKR_FUNCTION_FAILED; + if (ret == MEMORY_E) { + rv = CKR_DEVICE_MEMORY; + WOLFPKCS11_LEAVE("C_SeedRandom", rv); + return rv; + } + if (ret != 0) { + rv = CKR_FUNCTION_FAILED; + WOLFPKCS11_LEAVE("C_SeedRandom", rv); + return rv; + } - return CKR_OK; + rv = CKR_OK; + WOLFPKCS11_LEAVE("C_SeedRandom", rv); + return rv; } /** @@ -6601,20 +7448,48 @@ CK_RV C_GenerateRandom(CK_SESSION_HANDLE hSession, int ret; WP11_Session* session; WP11_Slot* slot; + CK_RV rv; - if (!WP11_Library_IsInitialized()) - return CKR_CRYPTOKI_NOT_INITIALIZED; - if (WP11_Session_Get(hSession, &session) != 0) - return CKR_SESSION_HANDLE_INVALID; - if (pRandomData == NULL) - return CKR_ARGUMENTS_BAD; + WOLFPKCS11_ENTER("C_GenerateRandom"); + #ifdef DEBUG_WOLFPKCS11 + if (wolfpkcs11_debugging) { + char paramStr[256]; + snprintf(paramStr, sizeof(paramStr), " hSession=%lu, ulRandomLen=%lu", + (unsigned long)hSession, (unsigned long)ulRandomLen); + WOLFPKCS11_MSG(paramStr); + } + #endif + + if (!WP11_Library_IsInitialized()) { + rv = CKR_CRYPTOKI_NOT_INITIALIZED; + WOLFPKCS11_LEAVE("C_GenerateRandom", rv); + return rv; + } + if (WP11_Session_Get(hSession, &session) != 0) { + rv = CKR_SESSION_HANDLE_INVALID; + WOLFPKCS11_LEAVE("C_GenerateRandom", rv); + return rv; + } + if (pRandomData == NULL) { + rv = CKR_ARGUMENTS_BAD; + WOLFPKCS11_LEAVE("C_GenerateRandom", rv); + return rv; + } slot = WP11_Session_GetSlot(session); ret = WP11_Slot_GenerateRandom(slot, pRandomData, (int)ulRandomLen); - if (ret == MEMORY_E) - return CKR_DEVICE_MEMORY; - if (ret != 0) - return CKR_FUNCTION_FAILED; + if (ret == MEMORY_E) { + rv = CKR_DEVICE_MEMORY; + WOLFPKCS11_LEAVE("C_GenerateRandom", rv); + return rv; + } + if (ret != 0) { + rv = CKR_FUNCTION_FAILED; + WOLFPKCS11_LEAVE("C_GenerateRandom", rv); + return rv; + } - return CKR_OK; + rv = CKR_OK; + WOLFPKCS11_LEAVE("C_GenerateRandom", rv); + return rv; } diff --git a/src/slot.c b/src/slot.c index ab8b8200..fee947cb 100644 --- a/src/slot.c +++ b/src/slot.c @@ -194,6 +194,7 @@ static CK_TOKEN_INFO tokenInfoTemplate = { */ CK_RV C_GetTokenInfo(CK_SLOT_ID slotID, CK_TOKEN_INFO_PTR pInfo) { + CK_RV rv; #ifndef WOLFPKCS11_NO_TIME time_t now, expire; struct tm nowTM; @@ -201,12 +202,30 @@ CK_RV C_GetTokenInfo(CK_SLOT_ID slotID, CK_TOKEN_INFO_PTR pInfo) WP11_Slot* slot; int cnt; - if (!WP11_Library_IsInitialized()) - return CKR_CRYPTOKI_NOT_INITIALIZED; - if (WP11_Slot_Get(slotID, &slot) != 0) - return CKR_SLOT_ID_INVALID; - if (pInfo == NULL) - return CKR_ARGUMENTS_BAD; + WOLFPKCS11_ENTER("C_GetTokenInfo"); + #ifdef DEBUG_WOLFPKCS11 + if (wolfpkcs11_debugging) { + char paramStr[256]; + snprintf(paramStr, sizeof(paramStr), " slotID=%lu", (unsigned long)slotID); + WOLFPKCS11_MSG(paramStr); + } + #endif + + if (!WP11_Library_IsInitialized()) { + rv = CKR_CRYPTOKI_NOT_INITIALIZED; + WOLFPKCS11_LEAVE("C_GetTokenInfo", rv); + return rv; + } + if (WP11_Slot_Get(slotID, &slot) != 0) { + rv = CKR_SLOT_ID_INVALID; + WOLFPKCS11_LEAVE("C_GetTokenInfo", rv); + return rv; + } + if (pInfo == NULL) { + rv = CKR_ARGUMENTS_BAD; + WOLFPKCS11_LEAVE("C_GetTokenInfo", rv); + return rv; + } XMEMCPY(pInfo, &tokenInfoTemplate, sizeof(tokenInfoTemplate)); WP11_Slot_GetTokenLabel(slot, (char*)pInfo->label); @@ -464,26 +483,54 @@ CK_RV C_GetMechanismList(CK_SLOT_ID slotID, CK_MECHANISM_TYPE_PTR pMechanismList, CK_ULONG_PTR pulCount) { + CK_RV rv; int i; - if (!WP11_Library_IsInitialized()) - return CKR_CRYPTOKI_NOT_INITIALIZED; - if (!WP11_SlotIdValid(slotID)) - return CKR_SLOT_ID_INVALID; - if (pulCount == NULL) - return CKR_ARGUMENTS_BAD; + WOLFPKCS11_ENTER("C_GetMechanismList"); + #ifdef DEBUG_WOLFPKCS11 + if (wolfpkcs11_debugging) { + char paramStr[256]; + snprintf(paramStr, sizeof(paramStr), " slotID=%lu", (unsigned long)slotID); + WOLFPKCS11_MSG(paramStr); + } + #endif - if (pMechanismList == NULL) + if (!WP11_Library_IsInitialized()) { + rv = CKR_CRYPTOKI_NOT_INITIALIZED; + WOLFPKCS11_LEAVE("C_GetMechanismList", rv); + return rv; + } + if (!WP11_SlotIdValid(slotID)) { + rv = CKR_SLOT_ID_INVALID; + WOLFPKCS11_LEAVE("C_GetMechanismList", rv); + return rv; + } + if (pulCount == NULL) { + rv = CKR_ARGUMENTS_BAD; + WOLFPKCS11_LEAVE("C_GetMechanismList", rv); + return rv; + } + + if (pMechanismList == NULL) { *pulCount = mechanismCnt; - else if (*pulCount < (CK_ULONG)mechanismCnt) - return CKR_BUFFER_TOO_SMALL; + rv = CKR_OK; + WOLFPKCS11_LEAVE("C_GetMechanismList", rv); + return rv; + } + else if (*pulCount < (CK_ULONG)mechanismCnt) { + rv = CKR_BUFFER_TOO_SMALL; + WOLFPKCS11_LEAVE("C_GetMechanismList", rv); + return rv; + } else { for (i = 0; i < mechanismCnt; i++) pMechanismList[i] = mechanismList[i]; *pulCount = mechanismCnt; } - return CKR_OK; + rv = CKR_OK; + WOLFPKCS11_LEAVE("C_GetMechanismList", rv); + return rv; } #ifndef NO_RSA @@ -757,12 +804,32 @@ static CK_MECHANISM_INFO genSecKeyGenMechInfo = { CK_RV C_GetMechanismInfo(CK_SLOT_ID slotID, CK_MECHANISM_TYPE type, CK_MECHANISM_INFO_PTR pInfo) { - if (!WP11_Library_IsInitialized()) - return CKR_CRYPTOKI_NOT_INITIALIZED; - if (!WP11_SlotIdValid(slotID)) - return CKR_SLOT_ID_INVALID; - if (pInfo == NULL) - return CKR_ARGUMENTS_BAD; + CK_RV rv; + + WOLFPKCS11_ENTER("C_GetMechanismInfo"); + #ifdef DEBUG_WOLFPKCS11 + if (wolfpkcs11_debugging) { + char paramStr[256]; + snprintf(paramStr, sizeof(paramStr), " slotID=%lu, type=%lu", (unsigned long)slotID, (unsigned long)type); + WOLFPKCS11_MSG(paramStr); + } + #endif + + if (!WP11_Library_IsInitialized()) { + rv = CKR_CRYPTOKI_NOT_INITIALIZED; + WOLFPKCS11_LEAVE("C_GetMechanismInfo", rv); + return rv; + } + if (!WP11_SlotIdValid(slotID)) { + rv = CKR_SLOT_ID_INVALID; + WOLFPKCS11_LEAVE("C_GetMechanismInfo", rv); + return rv; + } + if (pInfo == NULL) { + rv = CKR_ARGUMENTS_BAD; + WOLFPKCS11_LEAVE("C_GetMechanismInfo", rv); + return rv; + } switch (type) { #ifndef NO_RSA @@ -1073,34 +1140,67 @@ CK_RV C_GetMechanismInfo(CK_SLOT_ID slotID, CK_MECHANISM_TYPE type, CK_RV C_InitToken(CK_SLOT_ID slotID, CK_UTF8CHAR_PTR pPin, CK_ULONG ulPinLen, CK_UTF8CHAR_PTR pLabel) { + CK_RV rv; int ret; WP11_Slot* slot; - if (!WP11_Library_IsInitialized()) - return CKR_CRYPTOKI_NOT_INITIALIZED; - if (WP11_Slot_Get(slotID, &slot) != 0) - return CKR_SLOT_ID_INVALID; - if (pPin == NULL || pLabel == NULL) - return CKR_ARGUMENTS_BAD; + WOLFPKCS11_ENTER("C_InitToken"); + #ifdef DEBUG_WOLFPKCS11 + if (wolfpkcs11_debugging) { + char paramStr[256]; + snprintf(paramStr, sizeof(paramStr), " slotID=%lu, ulPinLen=%lu", (unsigned long)slotID, (unsigned long)ulPinLen); + WOLFPKCS11_MSG(paramStr); + } + #endif - if (checkPinLen(ulPinLen) != CKR_OK) - return CKR_PIN_INCORRECT; + if (!WP11_Library_IsInitialized()) { + rv = CKR_CRYPTOKI_NOT_INITIALIZED; + WOLFPKCS11_LEAVE("C_InitToken", rv); + return rv; + } + if (WP11_Slot_Get(slotID, &slot) != 0) { + rv = CKR_SLOT_ID_INVALID; + WOLFPKCS11_LEAVE("C_InitToken", rv); + return rv; + } + if (pPin == NULL || pLabel == NULL) { + rv = CKR_ARGUMENTS_BAD; + WOLFPKCS11_LEAVE("C_InitToken", rv); + return rv; + } + + if (checkPinLen(ulPinLen) != CKR_OK) { + rv = CKR_PIN_INCORRECT; + WOLFPKCS11_LEAVE("C_InitToken", rv); + return rv; + } if (WP11_Slot_IsTokenInitialized(slot)) { - if (WP11_Slot_HasSession(slot)) - return CKR_SESSION_EXISTS; + if (WP11_Slot_HasSession(slot)) { + rv = CKR_SESSION_EXISTS; + WOLFPKCS11_LEAVE("C_InitToken", rv); + return rv; + } if (WP11_Slot_SOPin_IsSet(slot)) { ret = WP11_Slot_CheckSOPin(slot, (char*)pPin, (int)ulPinLen); - if (ret != 0) - return CKR_PIN_INCORRECT; + if (ret != 0) { + rv = CKR_PIN_INCORRECT; + WOLFPKCS11_LEAVE("C_InitToken", rv); + return rv; + } } } ret = WP11_Slot_TokenReset(slot, (char*)pPin, (int)ulPinLen, (char*)pLabel); - if (ret != 0) - return CKR_FUNCTION_FAILED; + if (ret != 0) { + rv = CKR_FUNCTION_FAILED; + WOLFPKCS11_LEAVE("C_InitToken", rv); + return rv; + } - return CKR_OK; + rv = CKR_OK; + WOLFPKCS11_LEAVE("C_InitToken", rv); + return rv; } /** @@ -1120,28 +1220,58 @@ CK_RV C_InitToken(CK_SLOT_ID slotID, CK_UTF8CHAR_PTR pPin, CK_RV C_InitPIN(CK_SESSION_HANDLE hSession, CK_UTF8CHAR_PTR pPin, CK_ULONG ulPinLen) { + CK_RV rv; int ret; WP11_Slot* slot; WP11_Session* session; - if (!WP11_Library_IsInitialized()) - return CKR_CRYPTOKI_NOT_INITIALIZED; - if (WP11_Session_Get(hSession, &session) != 0) - return CKR_SESSION_HANDLE_INVALID; - if (pPin == NULL && ulPinLen > 0) - return CKR_ARGUMENTS_BAD; - if (WP11_Session_GetState(session) != WP11_APP_STATE_RW_SO) - return CKR_USER_NOT_LOGGED_IN; + WOLFPKCS11_ENTER("C_InitPIN"); + #ifdef DEBUG_WOLFPKCS11 + if (wolfpkcs11_debugging) { + char paramStr[256]; + snprintf(paramStr, sizeof(paramStr), " hSession=%lu, ulPinLen=%lu", (unsigned long)hSession, (unsigned long)ulPinLen); + WOLFPKCS11_MSG(paramStr); + } + #endif - if (checkPinLen(ulPinLen) != CKR_OK) - return CKR_PIN_INCORRECT; + if (!WP11_Library_IsInitialized()) { + rv = CKR_CRYPTOKI_NOT_INITIALIZED; + WOLFPKCS11_LEAVE("C_InitPIN", rv); + return rv; + } + if (WP11_Session_Get(hSession, &session) != 0) { + rv = CKR_SESSION_HANDLE_INVALID; + WOLFPKCS11_LEAVE("C_InitPIN", rv); + return rv; + } + if (pPin == NULL && ulPinLen > 0) { + rv = CKR_ARGUMENTS_BAD; + WOLFPKCS11_LEAVE("C_InitPIN", rv); + return rv; + } + if (WP11_Session_GetState(session) != WP11_APP_STATE_RW_SO) { + rv = CKR_USER_NOT_LOGGED_IN; + WOLFPKCS11_LEAVE("C_InitPIN", rv); + return rv; + } + + if (checkPinLen(ulPinLen) != CKR_OK) { + rv = CKR_PIN_INCORRECT; + WOLFPKCS11_LEAVE("C_InitPIN", rv); + return rv; + } slot = WP11_Session_GetSlot(session); ret = WP11_Slot_SetUserPin(slot, (char*)pPin, (int)ulPinLen); - if (ret != 0) - return CKR_FUNCTION_FAILED; + if (ret != 0) { + rv = CKR_FUNCTION_FAILED; + WOLFPKCS11_LEAVE("C_InitPIN", rv); + return rv; + } - return CKR_OK; + rv = CKR_OK; + WOLFPKCS11_LEAVE("C_InitPIN", rv); + return rv; } /** @@ -1170,49 +1300,97 @@ CK_RV C_SetPIN(CK_SESSION_HANDLE hSession, CK_UTF8CHAR_PTR pOldPin, int state; WP11_Slot* slot; WP11_Session* session; + CK_RV rv; - if (!WP11_Library_IsInitialized()) - return CKR_CRYPTOKI_NOT_INITIALIZED; - if (WP11_Session_Get(hSession, &session) != 0) - return CKR_SESSION_HANDLE_INVALID; - if (pOldPin == NULL || pNewPin == NULL) - return CKR_ARGUMENTS_BAD; - if (checkPinLen(ulOldLen) != CKR_OK) - return CKR_PIN_INCORRECT; - if (checkPinLen(ulNewLen) != CKR_OK) - return CKR_PIN_INCORRECT; + WOLFPKCS11_ENTER("C_SetPIN"); + #ifdef DEBUG_WOLFPKCS11 + if (wolfpkcs11_debugging) { + char paramStr[256]; + snprintf(paramStr, sizeof(paramStr), " hSession=%lu, ulOldLen=%lu, ulNewLen=%lu", + (unsigned long)hSession, (unsigned long)ulOldLen, (unsigned long)ulNewLen); + WOLFPKCS11_MSG(paramStr); + } + #endif + + if (!WP11_Library_IsInitialized()) { + rv = CKR_CRYPTOKI_NOT_INITIALIZED; + WOLFPKCS11_LEAVE("C_SetPIN", rv); + return rv; + } + if (WP11_Session_Get(hSession, &session) != 0) { + rv = CKR_SESSION_HANDLE_INVALID; + WOLFPKCS11_LEAVE("C_SetPIN", rv); + return rv; + } + if (pOldPin == NULL || pNewPin == NULL) { + rv = CKR_ARGUMENTS_BAD; + WOLFPKCS11_LEAVE("C_SetPIN", rv); + return rv; + } + if (checkPinLen(ulOldLen) != CKR_OK) { + rv = CKR_PIN_INCORRECT; + WOLFPKCS11_LEAVE("C_SetPIN", rv); + return rv; + } + if (checkPinLen(ulNewLen) != CKR_OK) { + rv = CKR_PIN_INCORRECT; + WOLFPKCS11_LEAVE("C_SetPIN", rv); + return rv; + } state = WP11_Session_GetState(session); if (state != WP11_APP_STATE_RW_SO && state != WP11_APP_STATE_RW_USER && state != WP11_APP_STATE_RW_PUBLIC) { - return CKR_SESSION_READ_ONLY; + rv = CKR_SESSION_READ_ONLY; + WOLFPKCS11_LEAVE("C_SetPIN", rv); + return rv; } slot = WP11_Session_GetSlot(session); if (state == WP11_APP_STATE_RW_SO) { ret = WP11_Slot_CheckSOPin(slot, (char*)pOldPin, (int)ulOldLen); - if (ret == PIN_NOT_SET_E) - return CKR_USER_PIN_NOT_INITIALIZED; - if (ret != 0) - return CKR_PIN_INCORRECT; + if (ret == PIN_NOT_SET_E) { + rv = CKR_USER_PIN_NOT_INITIALIZED; + WOLFPKCS11_LEAVE("C_SetPIN", rv); + return rv; + } + if (ret != 0) { + rv = CKR_PIN_INCORRECT; + WOLFPKCS11_LEAVE("C_SetPIN", rv); + return rv; + } ret = WP11_Slot_SetSOPin(slot, (char*)pNewPin, (int)ulNewLen); - if (ret != 0) - return CKR_FUNCTION_FAILED; + if (ret != 0) { + rv = CKR_FUNCTION_FAILED; + WOLFPKCS11_LEAVE("C_SetPIN", rv); + return rv; + } } else { ret = WP11_Slot_CheckUserPin(slot, (char*)pOldPin, (int)ulOldLen); - if (ret == PIN_NOT_SET_E) - return CKR_USER_PIN_NOT_INITIALIZED; - if (ret != 0) - return CKR_PIN_INCORRECT; + if (ret == PIN_NOT_SET_E) { + rv = CKR_USER_PIN_NOT_INITIALIZED; + WOLFPKCS11_LEAVE("C_SetPIN", rv); + return rv; + } + if (ret != 0) { + rv = CKR_PIN_INCORRECT; + WOLFPKCS11_LEAVE("C_SetPIN", rv); + return rv; + } ret = WP11_Slot_SetUserPin(slot, (char*)pNewPin, (int)ulNewLen); - if (ret != 0) - return CKR_FUNCTION_FAILED; + if (ret != 0) { + rv = CKR_FUNCTION_FAILED; + WOLFPKCS11_LEAVE("C_SetPIN", rv); + return rv; + } } - return CKR_OK; + rv = CKR_OK; + WOLFPKCS11_LEAVE("C_SetPIN", rv); + return rv; } /** @@ -1240,25 +1418,55 @@ CK_RV C_OpenSession(CK_SLOT_ID slotID, CK_FLAGS flags, CK_VOID_PTR pApplication, CK_NOTIFY Notify, CK_SESSION_HANDLE_PTR phSession) { + CK_RV rv; WP11_Slot* slot; int ret; - if (!WP11_Library_IsInitialized()) - return CKR_CRYPTOKI_NOT_INITIALIZED; - if (WP11_Slot_Get(slotID, &slot) != 0) - return CKR_SLOT_ID_INVALID; - if ((flags & CKF_SERIAL_SESSION) == 0) - return CKR_SESSION_PARALLEL_NOT_SUPPORTED; - if (phSession == NULL) - return CKR_ARGUMENTS_BAD; + WOLFPKCS11_ENTER("C_OpenSession"); + #ifdef DEBUG_WOLFPKCS11 + if (wolfpkcs11_debugging) { + char paramStr[256]; + snprintf(paramStr, sizeof(paramStr), " slotID=%lu, flags=%lu", (unsigned long)slotID, (unsigned long)flags); + WOLFPKCS11_MSG(paramStr); + } + #endif + + if (!WP11_Library_IsInitialized()) { + rv = CKR_CRYPTOKI_NOT_INITIALIZED; + WOLFPKCS11_LEAVE("C_OpenSession", rv); + return rv; + } + if (WP11_Slot_Get(slotID, &slot) != 0) { + rv = CKR_SLOT_ID_INVALID; + WOLFPKCS11_LEAVE("C_OpenSession", rv); + return rv; + } + if ((flags & CKF_SERIAL_SESSION) == 0) { + rv = CKR_SESSION_PARALLEL_NOT_SUPPORTED; + WOLFPKCS11_LEAVE("C_OpenSession", rv); + return rv; + } + if (phSession == NULL) { + rv = CKR_ARGUMENTS_BAD; + WOLFPKCS11_LEAVE("C_OpenSession", rv); + return rv; + } ret = WP11_Slot_OpenSession(slot, flags, pApplication, Notify, phSession); - if (ret == SESSION_EXISTS_E) - return CKR_SESSION_READ_WRITE_SO_EXISTS; - if (ret == SESSION_COUNT_E) - return CKR_SESSION_COUNT; + if (ret == SESSION_EXISTS_E) { + rv = CKR_SESSION_READ_WRITE_SO_EXISTS; + WOLFPKCS11_LEAVE("C_OpenSession", rv); + return rv; + } + if (ret == SESSION_COUNT_E) { + rv = CKR_SESSION_COUNT; + WOLFPKCS11_LEAVE("C_OpenSession", rv); + return rv; + } - return CKR_OK; + rv = CKR_OK; + WOLFPKCS11_LEAVE("C_OpenSession", rv); + return rv; } /** @@ -1271,18 +1479,36 @@ CK_RV C_OpenSession(CK_SLOT_ID slotID, CK_FLAGS flags, */ CK_RV C_CloseSession(CK_SESSION_HANDLE hSession) { + CK_RV rv; WP11_Slot* slot; WP11_Session* session; - if (!WP11_Library_IsInitialized()) - return CKR_CRYPTOKI_NOT_INITIALIZED; - if (WP11_Session_Get(hSession, &session) != 0) - return CKR_SESSION_HANDLE_INVALID; + WOLFPKCS11_ENTER("C_CloseSession"); + #ifdef DEBUG_WOLFPKCS11 + if (wolfpkcs11_debugging) { + char paramStr[256]; + snprintf(paramStr, sizeof(paramStr), " hSession=%lu", (unsigned long)hSession); + WOLFPKCS11_MSG(paramStr); + } + #endif + + if (!WP11_Library_IsInitialized()) { + rv = CKR_CRYPTOKI_NOT_INITIALIZED; + WOLFPKCS11_LEAVE("C_CloseSession", rv); + return rv; + } + if (WP11_Session_Get(hSession, &session) != 0) { + rv = CKR_SESSION_HANDLE_INVALID; + WOLFPKCS11_LEAVE("C_CloseSession", rv); + return rv; + } slot = WP11_Session_GetSlot(session); WP11_Slot_CloseSession(slot, session); - return CKR_OK; + rv = CKR_OK; + WOLFPKCS11_LEAVE("C_CloseSession", rv); + return rv; } /** @@ -1295,15 +1521,33 @@ CK_RV C_CloseSession(CK_SESSION_HANDLE hSession) */ CK_RV C_CloseAllSessions(CK_SLOT_ID slotID) { + CK_RV rv; WP11_Slot* slot; - if (!WP11_Library_IsInitialized()) - return CKR_CRYPTOKI_NOT_INITIALIZED; - if (WP11_Slot_Get(slotID, &slot) != 0) - return CKR_SLOT_ID_INVALID; + WOLFPKCS11_ENTER("C_CloseAllSessions"); + #ifdef DEBUG_WOLFPKCS11 + if (wolfpkcs11_debugging) { + char paramStr[256]; + snprintf(paramStr, sizeof(paramStr), " slotID=%lu", (unsigned long)slotID); + WOLFPKCS11_MSG(paramStr); + } + #endif + + if (!WP11_Library_IsInitialized()) { + rv = CKR_CRYPTOKI_NOT_INITIALIZED; + WOLFPKCS11_LEAVE("C_CloseAllSessions", rv); + return rv; + } + if (WP11_Slot_Get(slotID, &slot) != 0) { + rv = CKR_SLOT_ID_INVALID; + WOLFPKCS11_LEAVE("C_CloseAllSessions", rv); + return rv; + } WP11_Slot_CloseSessions(slot); - return CKR_OK; + rv = CKR_OK; + WOLFPKCS11_LEAVE("C_CloseAllSessions", rv); + return rv; } /** @@ -1319,14 +1563,33 @@ CK_RV C_CloseAllSessions(CK_SLOT_ID slotID) CK_RV C_GetSessionInfo(CK_SESSION_HANDLE hSession, CK_SESSION_INFO_PTR pInfo) { + CK_RV rv; WP11_Session* session; - if (!WP11_Library_IsInitialized()) - return CKR_CRYPTOKI_NOT_INITIALIZED; - if (WP11_Session_Get(hSession, &session) != 0) - return CKR_SESSION_HANDLE_INVALID; - if (pInfo == NULL) - return CKR_ARGUMENTS_BAD; + WOLFPKCS11_ENTER("C_GetSessionInfo"); + #ifdef DEBUG_WOLFPKCS11 + if (wolfpkcs11_debugging) { + char paramStr[256]; + snprintf(paramStr, sizeof(paramStr), " hSession=%lu", (unsigned long)hSession); + WOLFPKCS11_MSG(paramStr); + } + #endif + + if (!WP11_Library_IsInitialized()) { + rv = CKR_CRYPTOKI_NOT_INITIALIZED; + WOLFPKCS11_LEAVE("C_GetSessionInfo", rv); + return rv; + } + if (WP11_Session_Get(hSession, &session) != 0) { + rv = CKR_SESSION_HANDLE_INVALID; + WOLFPKCS11_LEAVE("C_GetSessionInfo", rv); + return rv; + } + if (pInfo == NULL) { + rv = CKR_ARGUMENTS_BAD; + WOLFPKCS11_LEAVE("C_GetSessionInfo", rv); + return rv; + } pInfo->state = WP11_Session_GetState(session); pInfo->flags = CKF_SERIAL_SESSION; @@ -1334,7 +1597,9 @@ CK_RV C_GetSessionInfo(CK_SESSION_HANDLE hSession, pInfo->flags |= CKF_RW_SESSION; pInfo->ulDeviceError = 0; - return CKR_OK; + rv = CKR_OK; + WOLFPKCS11_LEAVE("C_GetSessionInfo", rv); + return rv; } /** @@ -1357,16 +1622,36 @@ CK_RV C_GetOperationState(CK_SESSION_HANDLE hSession, CK_ULONG_PTR pulOperationStateLen) { WP11_Session* session; + CK_RV rv; + + WOLFPKCS11_ENTER("C_GetOperationState"); + #ifdef DEBUG_WOLFPKCS11 + if (wolfpkcs11_debugging) { + char paramStr[256]; + snprintf(paramStr, sizeof(paramStr), " hSession=%lu", (unsigned long)hSession); + WOLFPKCS11_MSG(paramStr); + } + #endif - if (!WP11_Library_IsInitialized()) - return CKR_CRYPTOKI_NOT_INITIALIZED; - if (WP11_Session_Get(hSession, &session) != 0) - return CKR_SESSION_HANDLE_INVALID; - if (pulOperationStateLen == NULL) - return CKR_ARGUMENTS_BAD; + if (!WP11_Library_IsInitialized()) { + rv = CKR_CRYPTOKI_NOT_INITIALIZED; + WOLFPKCS11_LEAVE("C_GetOperationState", rv); + return rv; + } + if (WP11_Session_Get(hSession, &session) != 0) { + rv = CKR_SESSION_HANDLE_INVALID; + WOLFPKCS11_LEAVE("C_GetOperationState", rv); + return rv; + } + if (pulOperationStateLen == NULL) { + rv = CKR_ARGUMENTS_BAD; + WOLFPKCS11_LEAVE("C_GetOperationState", rv); + return rv; + } - return WP11_GetOperationState(session, pOperationState, - pulOperationStateLen); + rv = WP11_GetOperationState(session, pOperationState, pulOperationStateLen); + WOLFPKCS11_LEAVE("C_GetOperationState", rv); + return rv; } /** @@ -1390,19 +1675,40 @@ CK_RV C_SetOperationState(CK_SESSION_HANDLE hSession, CK_OBJECT_HANDLE hAuthenticationKey) { WP11_Session* session; + CK_RV rv; - if (!WP11_Library_IsInitialized()) - return CKR_CRYPTOKI_NOT_INITIALIZED; - if (WP11_Session_Get(hSession, &session) != 0) - return CKR_SESSION_HANDLE_INVALID; - if (pOperationState == NULL) - return CKR_ARGUMENTS_BAD; + WOLFPKCS11_ENTER("C_SetOperationState"); + #ifdef DEBUG_WOLFPKCS11 + if (wolfpkcs11_debugging) { + char paramStr[256]; + snprintf(paramStr, sizeof(paramStr), " hSession=%lu, ulOperationStateLen=%lu", + (unsigned long)hSession, (unsigned long)ulOperationStateLen); + WOLFPKCS11_MSG(paramStr); + } + #endif + + if (!WP11_Library_IsInitialized()) { + rv = CKR_CRYPTOKI_NOT_INITIALIZED; + WOLFPKCS11_LEAVE("C_SetOperationState", rv); + return rv; + } + if (WP11_Session_Get(hSession, &session) != 0) { + rv = CKR_SESSION_HANDLE_INVALID; + WOLFPKCS11_LEAVE("C_SetOperationState", rv); + return rv; + } + if (pOperationState == NULL) { + rv = CKR_ARGUMENTS_BAD; + WOLFPKCS11_LEAVE("C_SetOperationState", rv); + return rv; + } (void)hEncryptionKey; (void)hAuthenticationKey; - return WP11_SetOperationState(session, pOperationState, - ulOperationStateLen); + rv = WP11_SetOperationState(session, pOperationState, ulOperationStateLen); + WOLFPKCS11_LEAVE("C_SetOperationState", rv); + return rv; } /** @@ -1437,8 +1743,10 @@ CK_RV C_Login(CK_SESSION_HANDLE hSession, CK_USER_TYPE userType, WOLFPKCS11_ENTER("C_Login"); #ifdef DEBUG_WOLFPKCS11 if (wolfpkcs11_debugging) { - printf(" hSession=%lu, userType=%lu, ulPinLen=%lu\n", - (unsigned long)hSession, (unsigned long)userType, (unsigned long)ulPinLen); + char paramStr[256]; + snprintf(paramStr, sizeof(paramStr), " hSession=%lu, userType=%lu, ulPinLen=%lu", + (unsigned long)hSession, (unsigned long)userType, (unsigned long)ulPinLen); + WOLFPKCS11_MSG(paramStr); } #endif @@ -1532,18 +1840,36 @@ CK_RV C_Login(CK_SESSION_HANDLE hSession, CK_USER_TYPE userType, */ CK_RV C_Logout(CK_SESSION_HANDLE hSession) { + CK_RV rv; WP11_Slot* slot; WP11_Session* session; - if (!WP11_Library_IsInitialized()) - return CKR_CRYPTOKI_NOT_INITIALIZED; - if (WP11_Session_Get(hSession, &session) != 0) - return CKR_SESSION_HANDLE_INVALID; + WOLFPKCS11_ENTER("C_Logout"); + #ifdef DEBUG_WOLFPKCS11 + if (wolfpkcs11_debugging) { + char paramStr[256]; + snprintf(paramStr, sizeof(paramStr), " hSession=%lu", (unsigned long)hSession); + WOLFPKCS11_MSG(paramStr); + } + #endif + + if (!WP11_Library_IsInitialized()) { + rv = CKR_CRYPTOKI_NOT_INITIALIZED; + WOLFPKCS11_LEAVE("C_Logout", rv); + return rv; + } + if (WP11_Session_Get(hSession, &session) != 0) { + rv = CKR_SESSION_HANDLE_INVALID; + WOLFPKCS11_LEAVE("C_Logout", rv); + return rv; + } slot = WP11_Session_GetSlot(session); WP11_Slot_Logout(slot); - return CKR_OK; + rv = CKR_OK; + WOLFPKCS11_LEAVE("C_Logout", rv); + return rv; } /** @@ -1557,12 +1883,30 @@ CK_RV C_Logout(CK_SESSION_HANDLE hSession) CK_RV C_GetFunctionStatus(CK_SESSION_HANDLE hSession) { WP11_Session* session; + CK_RV rv; - if (!WP11_Library_IsInitialized()) - return CKR_CRYPTOKI_NOT_INITIALIZED; - if (WP11_Session_Get(hSession, &session) != 0) - return CKR_SESSION_HANDLE_INVALID; - return CKR_FUNCTION_NOT_PARALLEL; + WOLFPKCS11_ENTER("C_GetFunctionStatus"); + #ifdef DEBUG_WOLFPKCS11 + if (wolfpkcs11_debugging) { + char paramStr[256]; + snprintf(paramStr, sizeof(paramStr), " hSession=%lu", (unsigned long)hSession); + WOLFPKCS11_MSG(paramStr); + } + #endif + + if (!WP11_Library_IsInitialized()) { + rv = CKR_CRYPTOKI_NOT_INITIALIZED; + WOLFPKCS11_LEAVE("C_GetFunctionStatus", rv); + return rv; + } + if (WP11_Session_Get(hSession, &session) != 0) { + rv = CKR_SESSION_HANDLE_INVALID; + WOLFPKCS11_LEAVE("C_GetFunctionStatus", rv); + return rv; + } + rv = CKR_FUNCTION_NOT_PARALLEL; + WOLFPKCS11_LEAVE("C_GetFunctionStatus", rv); + return rv; } /** @@ -1576,12 +1920,30 @@ CK_RV C_GetFunctionStatus(CK_SESSION_HANDLE hSession) CK_RV C_CancelFunction(CK_SESSION_HANDLE hSession) { WP11_Session* session; + CK_RV rv; + + WOLFPKCS11_ENTER("C_CancelFunction"); + #ifdef DEBUG_WOLFPKCS11 + if (wolfpkcs11_debugging) { + char paramStr[256]; + snprintf(paramStr, sizeof(paramStr), " hSession=%lu", (unsigned long)hSession); + WOLFPKCS11_MSG(paramStr); + } + #endif - if (!WP11_Library_IsInitialized()) - return CKR_CRYPTOKI_NOT_INITIALIZED; - if (WP11_Session_Get(hSession, &session) != 0) - return CKR_SESSION_HANDLE_INVALID; - return CKR_FUNCTION_NOT_PARALLEL; + if (!WP11_Library_IsInitialized()) { + rv = CKR_CRYPTOKI_NOT_INITIALIZED; + WOLFPKCS11_LEAVE("C_CancelFunction", rv); + return rv; + } + if (WP11_Session_Get(hSession, &session) != 0) { + rv = CKR_SESSION_HANDLE_INVALID; + WOLFPKCS11_LEAVE("C_CancelFunction", rv); + return rv; + } + rv = CKR_FUNCTION_NOT_PARALLEL; + WOLFPKCS11_LEAVE("C_CancelFunction", rv); + return rv; } /** @@ -1596,12 +1958,28 @@ CK_RV C_CancelFunction(CK_SESSION_HANDLE hSession) CK_RV C_WaitForSlotEvent(CK_FLAGS flags, CK_SLOT_ID_PTR pSlot, CK_VOID_PTR pReserved) { - if (!WP11_Library_IsInitialized()) - return CKR_CRYPTOKI_NOT_INITIALIZED; + CK_RV rv; + + WOLFPKCS11_ENTER("C_WaitForSlotEvent"); + #ifdef DEBUG_WOLFPKCS11 + if (wolfpkcs11_debugging) { + char paramStr[256]; + snprintf(paramStr, sizeof(paramStr), " flags=%lu", (unsigned long)flags); + WOLFPKCS11_MSG(paramStr); + } + #endif + + if (!WP11_Library_IsInitialized()) { + rv = CKR_CRYPTOKI_NOT_INITIALIZED; + WOLFPKCS11_LEAVE("C_WaitForSlotEvent", rv); + return rv; + } (void)pSlot; (void)flags; (void)pReserved; - return CKR_FUNCTION_NOT_SUPPORTED; + rv = CKR_FUNCTION_NOT_SUPPORTED; + WOLFPKCS11_LEAVE("C_WaitForSlotEvent", rv); + return rv; } diff --git a/wolfpkcs11/internal.h b/wolfpkcs11/internal.h index f0954a5e..3ad56ce8 100644 --- a/wolfpkcs11/internal.h +++ b/wolfpkcs11/internal.h @@ -618,12 +618,18 @@ extern int wolfpkcs11_debugging; void wolfPKCS11_Debugging_On(void); void wolfPKCS11_Debugging_Off(void); +#ifndef WOLFPKCS11_ENTER #define WOLFPKCS11_ENTER(funcName) \ do { if (wolfpkcs11_debugging) printf("WOLFPKCS11 ENTER: %s\n", funcName); } while(0) +#endif +#ifndef WOLFPKCS11_LEAVE #define WOLFPKCS11_LEAVE(funcName, ret) \ do { if (wolfpkcs11_debugging) printf("WOLFPKCS11 LEAVE: %s, returning %lu\n", funcName, (unsigned long)ret); } while(0) +#endif +#ifndef WOLFPKCS11_MSG #define WOLFPKCS11_MSG(msg) \ do { if (wolfpkcs11_debugging) printf("WOLFPKCS11: %s\n", msg); } while(0) +#endif #else #define WOLFPKCS11_ENTER(funcName) #define WOLFPKCS11_LEAVE(funcName, ret) From 5a1fd0468316243bcadff071538ead221e7e3748 Mon Sep 17 00:00:00 2001 From: Devin AI <158243242+devin-ai-integration[bot]@users.noreply.github.com> Date: Fri, 20 Jun 2025 14:03:54 +0000 Subject: [PATCH 03/13] Address user feedback: add varargs support to WOLFPKCS11_MSG, replace printf in slot.c, move debug_test.c to tests - Add varargs support to WOLFPKCS11_MSG macro for printf-style formatting - Replace all direct printf calls in slot.c with WOLFPKCS11_MSG macro calls - Convert all snprintf + WOLFPKCS11_MSG patterns to direct WOLFPKCS11_MSG calls - Move debug_test.c from root to tests directory as official test - Update tests/README.md to document debug_test.c purpose Co-Authored-By: andrew@wolfssl.com --- src/slot.c | 78 +++++++++--------------------- tests/README.md | 1 + debug_test.c => tests/debug_test.c | 0 wolfpkcs11/internal.h | 6 +-- 4 files changed, 26 insertions(+), 59 deletions(-) rename debug_test.c => tests/debug_test.c (100%) diff --git a/src/slot.c b/src/slot.c index fee947cb..35bd748c 100644 --- a/src/slot.c +++ b/src/slot.c @@ -51,7 +51,7 @@ CK_RV C_GetSlotList(CK_BBOOL tokenPresent, CK_SLOT_ID_PTR pSlotList, WOLFPKCS11_ENTER("C_GetSlotList"); #ifdef DEBUG_WOLFPKCS11 if (wolfpkcs11_debugging) { - printf(" tokenPresent=%s\n", tokenPresent ? "TRUE" : "FALSE"); + WOLFPKCS11_MSG(" tokenPresent=%s", tokenPresent ? "TRUE" : "FALSE"); } #endif @@ -113,7 +113,7 @@ CK_RV C_GetSlotInfo(CK_SLOT_ID slotID, CK_SLOT_INFO_PTR pInfo) WOLFPKCS11_ENTER("C_GetSlotInfo"); #ifdef DEBUG_WOLFPKCS11 if (wolfpkcs11_debugging) { - printf(" slotID=%lu\n", (unsigned long)slotID); + WOLFPKCS11_MSG(" slotID=%lu", (unsigned long)slotID); } #endif @@ -205,9 +205,7 @@ CK_RV C_GetTokenInfo(CK_SLOT_ID slotID, CK_TOKEN_INFO_PTR pInfo) WOLFPKCS11_ENTER("C_GetTokenInfo"); #ifdef DEBUG_WOLFPKCS11 if (wolfpkcs11_debugging) { - char paramStr[256]; - snprintf(paramStr, sizeof(paramStr), " slotID=%lu", (unsigned long)slotID); - WOLFPKCS11_MSG(paramStr); + WOLFPKCS11_MSG(" slotID=%lu", (unsigned long)slotID); } #endif @@ -489,9 +487,7 @@ CK_RV C_GetMechanismList(CK_SLOT_ID slotID, WOLFPKCS11_ENTER("C_GetMechanismList"); #ifdef DEBUG_WOLFPKCS11 if (wolfpkcs11_debugging) { - char paramStr[256]; - snprintf(paramStr, sizeof(paramStr), " slotID=%lu", (unsigned long)slotID); - WOLFPKCS11_MSG(paramStr); + WOLFPKCS11_MSG(" slotID=%lu", (unsigned long)slotID); } #endif @@ -809,9 +805,7 @@ CK_RV C_GetMechanismInfo(CK_SLOT_ID slotID, CK_MECHANISM_TYPE type, WOLFPKCS11_ENTER("C_GetMechanismInfo"); #ifdef DEBUG_WOLFPKCS11 if (wolfpkcs11_debugging) { - char paramStr[256]; - snprintf(paramStr, sizeof(paramStr), " slotID=%lu, type=%lu", (unsigned long)slotID, (unsigned long)type); - WOLFPKCS11_MSG(paramStr); + WOLFPKCS11_MSG(" slotID=%lu, type=%lu", (unsigned long)slotID, (unsigned long)type); } #endif @@ -1147,9 +1141,7 @@ CK_RV C_InitToken(CK_SLOT_ID slotID, CK_UTF8CHAR_PTR pPin, WOLFPKCS11_ENTER("C_InitToken"); #ifdef DEBUG_WOLFPKCS11 if (wolfpkcs11_debugging) { - char paramStr[256]; - snprintf(paramStr, sizeof(paramStr), " slotID=%lu, ulPinLen=%lu", (unsigned long)slotID, (unsigned long)ulPinLen); - WOLFPKCS11_MSG(paramStr); + WOLFPKCS11_MSG(" slotID=%lu, ulPinLen=%lu", (unsigned long)slotID, (unsigned long)ulPinLen); } #endif @@ -1228,9 +1220,7 @@ CK_RV C_InitPIN(CK_SESSION_HANDLE hSession, CK_UTF8CHAR_PTR pPin, WOLFPKCS11_ENTER("C_InitPIN"); #ifdef DEBUG_WOLFPKCS11 if (wolfpkcs11_debugging) { - char paramStr[256]; - snprintf(paramStr, sizeof(paramStr), " hSession=%lu, ulPinLen=%lu", (unsigned long)hSession, (unsigned long)ulPinLen); - WOLFPKCS11_MSG(paramStr); + WOLFPKCS11_MSG(" hSession=%lu, ulPinLen=%lu", (unsigned long)hSession, (unsigned long)ulPinLen); } #endif @@ -1305,10 +1295,8 @@ CK_RV C_SetPIN(CK_SESSION_HANDLE hSession, CK_UTF8CHAR_PTR pOldPin, WOLFPKCS11_ENTER("C_SetPIN"); #ifdef DEBUG_WOLFPKCS11 if (wolfpkcs11_debugging) { - char paramStr[256]; - snprintf(paramStr, sizeof(paramStr), " hSession=%lu, ulOldLen=%lu, ulNewLen=%lu", - (unsigned long)hSession, (unsigned long)ulOldLen, (unsigned long)ulNewLen); - WOLFPKCS11_MSG(paramStr); + WOLFPKCS11_MSG(" hSession=%lu, ulOldLen=%lu, ulNewLen=%lu", + (unsigned long)hSession, (unsigned long)ulOldLen, (unsigned long)ulNewLen); } #endif @@ -1425,9 +1413,7 @@ CK_RV C_OpenSession(CK_SLOT_ID slotID, CK_FLAGS flags, WOLFPKCS11_ENTER("C_OpenSession"); #ifdef DEBUG_WOLFPKCS11 if (wolfpkcs11_debugging) { - char paramStr[256]; - snprintf(paramStr, sizeof(paramStr), " slotID=%lu, flags=%lu", (unsigned long)slotID, (unsigned long)flags); - WOLFPKCS11_MSG(paramStr); + WOLFPKCS11_MSG(" slotID=%lu, flags=%lu", (unsigned long)slotID, (unsigned long)flags); } #endif @@ -1486,9 +1472,7 @@ CK_RV C_CloseSession(CK_SESSION_HANDLE hSession) WOLFPKCS11_ENTER("C_CloseSession"); #ifdef DEBUG_WOLFPKCS11 if (wolfpkcs11_debugging) { - char paramStr[256]; - snprintf(paramStr, sizeof(paramStr), " hSession=%lu", (unsigned long)hSession); - WOLFPKCS11_MSG(paramStr); + WOLFPKCS11_MSG(" hSession=%lu", (unsigned long)hSession); } #endif @@ -1527,9 +1511,7 @@ CK_RV C_CloseAllSessions(CK_SLOT_ID slotID) WOLFPKCS11_ENTER("C_CloseAllSessions"); #ifdef DEBUG_WOLFPKCS11 if (wolfpkcs11_debugging) { - char paramStr[256]; - snprintf(paramStr, sizeof(paramStr), " slotID=%lu", (unsigned long)slotID); - WOLFPKCS11_MSG(paramStr); + WOLFPKCS11_MSG(" slotID=%lu", (unsigned long)slotID); } #endif @@ -1569,9 +1551,7 @@ CK_RV C_GetSessionInfo(CK_SESSION_HANDLE hSession, WOLFPKCS11_ENTER("C_GetSessionInfo"); #ifdef DEBUG_WOLFPKCS11 if (wolfpkcs11_debugging) { - char paramStr[256]; - snprintf(paramStr, sizeof(paramStr), " hSession=%lu", (unsigned long)hSession); - WOLFPKCS11_MSG(paramStr); + WOLFPKCS11_MSG(" hSession=%lu", (unsigned long)hSession); } #endif @@ -1627,9 +1607,7 @@ CK_RV C_GetOperationState(CK_SESSION_HANDLE hSession, WOLFPKCS11_ENTER("C_GetOperationState"); #ifdef DEBUG_WOLFPKCS11 if (wolfpkcs11_debugging) { - char paramStr[256]; - snprintf(paramStr, sizeof(paramStr), " hSession=%lu", (unsigned long)hSession); - WOLFPKCS11_MSG(paramStr); + WOLFPKCS11_MSG(" hSession=%lu", (unsigned long)hSession); } #endif @@ -1680,10 +1658,8 @@ CK_RV C_SetOperationState(CK_SESSION_HANDLE hSession, WOLFPKCS11_ENTER("C_SetOperationState"); #ifdef DEBUG_WOLFPKCS11 if (wolfpkcs11_debugging) { - char paramStr[256]; - snprintf(paramStr, sizeof(paramStr), " hSession=%lu, ulOperationStateLen=%lu", - (unsigned long)hSession, (unsigned long)ulOperationStateLen); - WOLFPKCS11_MSG(paramStr); + WOLFPKCS11_MSG(" hSession=%lu, ulOperationStateLen=%lu", + (unsigned long)hSession, (unsigned long)ulOperationStateLen); } #endif @@ -1743,10 +1719,8 @@ CK_RV C_Login(CK_SESSION_HANDLE hSession, CK_USER_TYPE userType, WOLFPKCS11_ENTER("C_Login"); #ifdef DEBUG_WOLFPKCS11 if (wolfpkcs11_debugging) { - char paramStr[256]; - snprintf(paramStr, sizeof(paramStr), " hSession=%lu, userType=%lu, ulPinLen=%lu", - (unsigned long)hSession, (unsigned long)userType, (unsigned long)ulPinLen); - WOLFPKCS11_MSG(paramStr); + WOLFPKCS11_MSG(" hSession=%lu, userType=%lu, ulPinLen=%lu", + (unsigned long)hSession, (unsigned long)userType, (unsigned long)ulPinLen); } #endif @@ -1847,9 +1821,7 @@ CK_RV C_Logout(CK_SESSION_HANDLE hSession) WOLFPKCS11_ENTER("C_Logout"); #ifdef DEBUG_WOLFPKCS11 if (wolfpkcs11_debugging) { - char paramStr[256]; - snprintf(paramStr, sizeof(paramStr), " hSession=%lu", (unsigned long)hSession); - WOLFPKCS11_MSG(paramStr); + WOLFPKCS11_MSG(" hSession=%lu", (unsigned long)hSession); } #endif @@ -1888,9 +1860,7 @@ CK_RV C_GetFunctionStatus(CK_SESSION_HANDLE hSession) WOLFPKCS11_ENTER("C_GetFunctionStatus"); #ifdef DEBUG_WOLFPKCS11 if (wolfpkcs11_debugging) { - char paramStr[256]; - snprintf(paramStr, sizeof(paramStr), " hSession=%lu", (unsigned long)hSession); - WOLFPKCS11_MSG(paramStr); + WOLFPKCS11_MSG(" hSession=%lu", (unsigned long)hSession); } #endif @@ -1925,9 +1895,7 @@ CK_RV C_CancelFunction(CK_SESSION_HANDLE hSession) WOLFPKCS11_ENTER("C_CancelFunction"); #ifdef DEBUG_WOLFPKCS11 if (wolfpkcs11_debugging) { - char paramStr[256]; - snprintf(paramStr, sizeof(paramStr), " hSession=%lu", (unsigned long)hSession); - WOLFPKCS11_MSG(paramStr); + WOLFPKCS11_MSG(" hSession=%lu", (unsigned long)hSession); } #endif @@ -1963,9 +1931,7 @@ CK_RV C_WaitForSlotEvent(CK_FLAGS flags, CK_SLOT_ID_PTR pSlot, WOLFPKCS11_ENTER("C_WaitForSlotEvent"); #ifdef DEBUG_WOLFPKCS11 if (wolfpkcs11_debugging) { - char paramStr[256]; - snprintf(paramStr, sizeof(paramStr), " flags=%lu", (unsigned long)flags); - WOLFPKCS11_MSG(paramStr); + WOLFPKCS11_MSG(" flags=%lu", (unsigned long)flags); } #endif diff --git a/tests/README.md b/tests/README.md index 3c868cce..32fbe0be 100644 --- a/tests/README.md +++ b/tests/README.md @@ -4,3 +4,4 @@ The test files have the following purposes: * `pkcs11test.c`: is the standard tests * `pkcs11mtt.c`: is the multithreaded tests * `pkcs11str.c`: is a storage test +* `debug_test.c`: is a debug functionality demonstration test diff --git a/debug_test.c b/tests/debug_test.c similarity index 100% rename from debug_test.c rename to tests/debug_test.c diff --git a/wolfpkcs11/internal.h b/wolfpkcs11/internal.h index 3ad56ce8..852dc2ed 100644 --- a/wolfpkcs11/internal.h +++ b/wolfpkcs11/internal.h @@ -627,13 +627,13 @@ void wolfPKCS11_Debugging_Off(void); do { if (wolfpkcs11_debugging) printf("WOLFPKCS11 LEAVE: %s, returning %lu\n", funcName, (unsigned long)ret); } while(0) #endif #ifndef WOLFPKCS11_MSG -#define WOLFPKCS11_MSG(msg) \ - do { if (wolfpkcs11_debugging) printf("WOLFPKCS11: %s\n", msg); } while(0) +#define WOLFPKCS11_MSG(fmt, ...) \ + do { if (wolfpkcs11_debugging) printf("WOLFPKCS11: " fmt "\n", ##__VA_ARGS__); } while(0) #endif #else #define WOLFPKCS11_ENTER(funcName) #define WOLFPKCS11_LEAVE(funcName, ret) -#define WOLFPKCS11_MSG(msg) +#define WOLFPKCS11_MSG(fmt, ...) #endif #ifdef __cplusplus From 85cf875e11dcab957c5d16d24a34efa8eede820a Mon Sep 17 00:00:00 2001 From: Devin AI <158243242+devin-ai-integration[bot]@users.noreply.github.com> Date: Fri, 20 Jun 2025 14:14:10 +0000 Subject: [PATCH 04/13] Fix MSVC compilation errors by removing ##__VA_ARGS__ from WOLFPKCS11_MSG macro - Replace ##__VA_ARGS__ with standard __VA_ARGS__ for MSVC compatibility - Complete conversion of all snprintf + WOLFPKCS11_MSG patterns to direct varargs calls - Fixes 90 compilation errors in Windows CI build Co-Authored-By: andrew@wolfssl.com --- src/crypto.c | 213 +++++++++--------------------------------- wolfpkcs11/internal.h | 2 +- 2 files changed, 46 insertions(+), 169 deletions(-) diff --git a/src/crypto.c b/src/crypto.c index bebc781e..ca6c80fe 100644 --- a/src/crypto.c +++ b/src/crypto.c @@ -1011,9 +1011,7 @@ CK_RV C_CreateObject(CK_SESSION_HANDLE hSession, CK_ATTRIBUTE_PTR pTemplate, WOLFPKCS11_ENTER("C_CreateObject"); #ifdef DEBUG_WOLFPKCS11 if (wolfpkcs11_debugging) { - char paramStr[256]; - snprintf(paramStr, sizeof(paramStr), " hSession=%lu, ulCount=%lu", (unsigned long)hSession, (unsigned long)ulCount); - WOLFPKCS11_MSG(paramStr); + WOLFPKCS11_MSG(" hSession=%lu, ulCount=%lu", (unsigned long)hSession, (unsigned long)ulCount); } #endif @@ -1090,9 +1088,7 @@ CK_RV C_CopyObject(CK_SESSION_HANDLE hSession, CK_OBJECT_HANDLE hObject, WOLFPKCS11_ENTER("C_CopyObject"); #ifdef DEBUG_WOLFPKCS11 if (wolfpkcs11_debugging) { - char paramStr[256]; - snprintf(paramStr, sizeof(paramStr), " hSession=%lu, hObject=%lu, ulCount=%lu", (unsigned long)hSession, (unsigned long)hObject, (unsigned long)ulCount); - WOLFPKCS11_MSG(paramStr); + WOLFPKCS11_MSG(" hSession=%lu, hObject=%lu, ulCount=%lu", (unsigned long)hSession, (unsigned long)hObject, (unsigned long)ulCount); } #endif @@ -1186,9 +1182,7 @@ CK_RV C_DestroyObject(CK_SESSION_HANDLE hSession, WOLFPKCS11_ENTER("C_DestroyObject"); #ifdef DEBUG_WOLFPKCS11 if (wolfpkcs11_debugging) { - char paramStr[256]; - snprintf(paramStr, sizeof(paramStr), " hSession=%lu, hObject=%lu", (unsigned long)hSession, (unsigned long)hObject); - WOLFPKCS11_MSG(paramStr); + WOLFPKCS11_MSG(" hSession=%lu, hObject=%lu", (unsigned long)hSession, (unsigned long)hObject); } #endif @@ -1249,9 +1243,7 @@ CK_RV C_GetObjectSize(CK_SESSION_HANDLE hSession, WOLFPKCS11_ENTER("C_GetObjectSize"); #ifdef DEBUG_WOLFPKCS11 if (wolfpkcs11_debugging) { - char paramStr[256]; - snprintf(paramStr, sizeof(paramStr), " hSession=%lu, hObject=%lu", (unsigned long)hSession, (unsigned long)hObject); - WOLFPKCS11_MSG(paramStr); + WOLFPKCS11_MSG(" hSession=%lu, hObject=%lu", (unsigned long)hSession, (unsigned long)hObject); } #endif @@ -1318,9 +1310,7 @@ CK_RV C_GetAttributeValue(CK_SESSION_HANDLE hSession, WOLFPKCS11_ENTER("C_GetAttributeValue"); #ifdef DEBUG_WOLFPKCS11 if (wolfpkcs11_debugging) { - char paramStr[256]; - snprintf(paramStr, sizeof(paramStr), " hSession=%lu, hObject=%lu, ulCount=%lu", (unsigned long)hSession, (unsigned long)hObject, (unsigned long)ulCount); - WOLFPKCS11_MSG(paramStr); + WOLFPKCS11_MSG(" hSession=%lu, hObject=%lu, ulCount=%lu", (unsigned long)hSession, (unsigned long)hObject, (unsigned long)ulCount); } #endif @@ -1420,9 +1410,7 @@ CK_RV C_SetAttributeValue(CK_SESSION_HANDLE hSession, WOLFPKCS11_ENTER("C_SetAttributeValue"); #ifdef DEBUG_WOLFPKCS11 if (wolfpkcs11_debugging) { - char paramStr[256]; - snprintf(paramStr, sizeof(paramStr), " hSession=%lu, hObject=%lu, ulCount=%lu", (unsigned long)hSession, (unsigned long)hObject, (unsigned long)ulCount); - WOLFPKCS11_MSG(paramStr); + WOLFPKCS11_MSG(" hSession=%lu, hObject=%lu, ulCount=%lu", (unsigned long)hSession, (unsigned long)hObject, (unsigned long)ulCount); } #endif @@ -1486,9 +1474,7 @@ CK_RV C_FindObjectsInit(CK_SESSION_HANDLE hSession, WOLFPKCS11_ENTER("C_FindObjectsInit"); #ifdef DEBUG_WOLFPKCS11 if (wolfpkcs11_debugging) { - char paramStr[256]; - snprintf(paramStr, sizeof(paramStr), " hSession=%lu, ulCount=%lu", (unsigned long)hSession, (unsigned long)ulCount); - WOLFPKCS11_MSG(paramStr); + WOLFPKCS11_MSG(" hSession=%lu, ulCount=%lu", (unsigned long)hSession, (unsigned long)ulCount); } #endif @@ -1563,9 +1549,7 @@ CK_RV C_FindObjects(CK_SESSION_HANDLE hSession, WOLFPKCS11_ENTER("C_FindObjects"); #ifdef DEBUG_WOLFPKCS11 if (wolfpkcs11_debugging) { - char paramStr[256]; - snprintf(paramStr, sizeof(paramStr), " hSession=%lu, ulMaxObjectCount=%lu", (unsigned long)hSession, (unsigned long)ulMaxObjectCount); - WOLFPKCS11_MSG(paramStr); + WOLFPKCS11_MSG(" hSession=%lu, ulMaxObjectCount=%lu", (unsigned long)hSession, (unsigned long)ulMaxObjectCount); } #endif @@ -1614,9 +1598,7 @@ CK_RV C_FindObjectsFinal(CK_SESSION_HANDLE hSession) WOLFPKCS11_ENTER("C_FindObjectsFinal"); #ifdef DEBUG_WOLFPKCS11 if (wolfpkcs11_debugging) { - char paramStr[256]; - snprintf(paramStr, sizeof(paramStr), " hSession=%lu", (unsigned long)hSession); - WOLFPKCS11_MSG(paramStr); + WOLFPKCS11_MSG(" hSession=%lu", (unsigned long)hSession); } #endif @@ -1672,9 +1654,7 @@ CK_RV C_EncryptInit(CK_SESSION_HANDLE hSession, WOLFPKCS11_ENTER("C_EncryptInit"); #ifdef DEBUG_WOLFPKCS11 if (wolfpkcs11_debugging) { - char paramStr[256]; - snprintf(paramStr, sizeof(paramStr), " hSession=%lu, hKey=%lu", (unsigned long)hSession, (unsigned long)hKey); - WOLFPKCS11_MSG(paramStr); + WOLFPKCS11_MSG(" hSession=%lu, hKey=%lu", (unsigned long)hSession, (unsigned long)hKey); } #endif @@ -1958,9 +1938,7 @@ CK_RV C_Encrypt(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pData, WOLFPKCS11_ENTER("C_Encrypt"); #ifdef DEBUG_WOLFPKCS11 if (wolfpkcs11_debugging) { - char paramStr[256]; - snprintf(paramStr, sizeof(paramStr), " hSession=%lu, ulDataLen=%lu", (unsigned long)hSession, (unsigned long)ulDataLen); - WOLFPKCS11_MSG(paramStr); + WOLFPKCS11_MSG(" hSession=%lu, ulDataLen=%lu", (unsigned long)hSession, (unsigned long)ulDataLen); } #endif @@ -2295,10 +2273,7 @@ CK_RV C_EncryptUpdate(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pPart, WOLFPKCS11_ENTER("C_EncryptUpdate"); #ifdef DEBUG_WOLFPKCS11 if (wolfpkcs11_debugging) { - char paramStr[256]; - snprintf(paramStr, sizeof(paramStr), " hSession=%lu, ulPartLen=%lu", - (unsigned long)hSession, (unsigned long)ulPartLen); - WOLFPKCS11_MSG(paramStr); + WOLFPKCS11_MSG(" hSession=%lu, ulPartLen=%lu", (unsigned long)hSession, (unsigned long)ulPartLen); } #endif @@ -2489,10 +2464,7 @@ CK_RV C_EncryptFinal(CK_SESSION_HANDLE hSession, WOLFPKCS11_ENTER("C_EncryptFinal"); #ifdef DEBUG_WOLFPKCS11 if (wolfpkcs11_debugging) { - char paramStr[256]; - snprintf(paramStr, sizeof(paramStr), " hSession=%lu", - (unsigned long)hSession); - WOLFPKCS11_MSG(paramStr); + WOLFPKCS11_MSG(" hSession=%lu", (unsigned long)hSession); } #endif @@ -2651,10 +2623,7 @@ CK_RV C_DecryptInit(CK_SESSION_HANDLE hSession, WOLFPKCS11_ENTER("C_DecryptInit"); #ifdef DEBUG_WOLFPKCS11 if (wolfpkcs11_debugging) { - char paramStr[256]; - snprintf(paramStr, sizeof(paramStr), " hSession=%lu, hKey=%lu", - (unsigned long)hSession, (unsigned long)hKey); - WOLFPKCS11_MSG(paramStr); + WOLFPKCS11_MSG(" hSession=%lu, hKey=%lu", (unsigned long)hSession, (unsigned long)hKey); } #endif @@ -2923,10 +2892,7 @@ CK_RV C_Decrypt(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pEncryptedData, WOLFPKCS11_ENTER("C_Decrypt"); #ifdef DEBUG_WOLFPKCS11 if (wolfpkcs11_debugging) { - char paramStr[256]; - snprintf(paramStr, sizeof(paramStr), " hSession=%lu, ulEncryptedDataLen=%lu", - (unsigned long)hSession, (unsigned long)ulEncryptedDataLen); - WOLFPKCS11_MSG(paramStr); + WOLFPKCS11_MSG(" hSession=%lu, ulEncryptedDataLen=%lu", (unsigned long)hSession, (unsigned long)ulEncryptedDataLen); } #endif @@ -3239,10 +3205,7 @@ CK_RV C_DecryptUpdate(CK_SESSION_HANDLE hSession, WOLFPKCS11_ENTER("C_DecryptUpdate"); #ifdef DEBUG_WOLFPKCS11 if (wolfpkcs11_debugging) { - char paramStr[256]; - snprintf(paramStr, sizeof(paramStr), " hSession=%lu, ulEncryptedPartLen=%lu", - (unsigned long)hSession, (unsigned long)ulEncryptedPartLen); - WOLFPKCS11_MSG(paramStr); + WOLFPKCS11_MSG(" hSession=%lu, ulEncryptedPartLen=%lu", (unsigned long)hSession, (unsigned long)ulEncryptedPartLen); } #endif @@ -3412,10 +3375,7 @@ CK_RV C_DecryptFinal(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pLastPart, WOLFPKCS11_ENTER("C_DecryptFinal"); #ifdef DEBUG_WOLFPKCS11 if (wolfpkcs11_debugging) { - char paramStr[256]; - snprintf(paramStr, sizeof(paramStr), " hSession=%lu", - (unsigned long)hSession); - WOLFPKCS11_MSG(paramStr); + WOLFPKCS11_MSG(" hSession=%lu", (unsigned long)hSession); } #endif @@ -3565,9 +3525,7 @@ CK_RV C_DigestInit(CK_SESSION_HANDLE hSession, WOLFPKCS11_ENTER("C_DigestInit"); #ifdef DEBUG_WOLFPKCS11 if (wolfpkcs11_debugging) { - char paramStr[256]; - snprintf(paramStr, sizeof(paramStr), " hSession=%lu", (unsigned long)hSession); - WOLFPKCS11_MSG(paramStr); + WOLFPKCS11_MSG(" hSession=%lu", (unsigned long)hSession); } #endif @@ -3635,10 +3593,7 @@ CK_RV C_Digest(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pData, WOLFPKCS11_ENTER("C_Digest"); #ifdef DEBUG_WOLFPKCS11 if (wolfpkcs11_debugging) { - char paramStr[256]; - snprintf(paramStr, sizeof(paramStr), " hSession=%lu, ulDataLen=%lu", - (unsigned long)hSession, (unsigned long)ulDataLen); - WOLFPKCS11_MSG(paramStr); + WOLFPKCS11_MSG(" hSession=%lu, ulDataLen=%lu", (unsigned long)hSession, (unsigned long)ulDataLen); } #endif @@ -3683,10 +3638,7 @@ CK_RV C_DigestUpdate(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pPart, WOLFPKCS11_ENTER("C_DigestUpdate"); #ifdef DEBUG_WOLFPKCS11 if (wolfpkcs11_debugging) { - char paramStr[256]; - snprintf(paramStr, sizeof(paramStr), " hSession=%lu, ulPartLen=%lu", - (unsigned long)hSession, (unsigned long)ulPartLen); - WOLFPKCS11_MSG(paramStr); + WOLFPKCS11_MSG(" hSession=%lu, ulPartLen=%lu", (unsigned long)hSession, (unsigned long)ulPartLen); } #endif @@ -3729,10 +3681,7 @@ CK_RV C_DigestKey(CK_SESSION_HANDLE hSession, CK_OBJECT_HANDLE hKey) WOLFPKCS11_ENTER("C_DigestKey"); #ifdef DEBUG_WOLFPKCS11 if (wolfpkcs11_debugging) { - char paramStr[256]; - snprintf(paramStr, sizeof(paramStr), " hSession=%lu, hKey=%lu", - (unsigned long)hSession, (unsigned long)hKey); - WOLFPKCS11_MSG(paramStr); + WOLFPKCS11_MSG(" hSession=%lu, hKey=%lu", (unsigned long)hSession, (unsigned long)hKey); } #endif @@ -3779,10 +3728,7 @@ CK_RV C_DigestFinal(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pDigest, WOLFPKCS11_ENTER("C_DigestFinal"); #ifdef DEBUG_WOLFPKCS11 if (wolfpkcs11_debugging) { - char paramStr[256]; - snprintf(paramStr, sizeof(paramStr), " hSession=%lu", - (unsigned long)hSession); - WOLFPKCS11_MSG(paramStr); + WOLFPKCS11_MSG(" hSession=%lu", (unsigned long)hSession); } #endif @@ -3871,10 +3817,7 @@ CK_RV C_SignInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechanism, WOLFPKCS11_ENTER("C_SignInit"); #ifdef DEBUG_WOLFPKCS11 if (wolfpkcs11_debugging) { - char paramStr[256]; - snprintf(paramStr, sizeof(paramStr), " hSession=%lu, hKey=%lu", - (unsigned long)hSession, (unsigned long)hKey); - WOLFPKCS11_MSG(paramStr); + WOLFPKCS11_MSG(" hSession=%lu, hKey=%lu", (unsigned long)hSession, (unsigned long)hKey); } #endif @@ -4188,10 +4131,7 @@ CK_RV C_Sign(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pData, WOLFPKCS11_ENTER("C_Sign"); #ifdef DEBUG_WOLFPKCS11 if (wolfpkcs11_debugging) { - char paramStr[256]; - snprintf(paramStr, sizeof(paramStr), " hSession=%lu, ulDataLen=%lu", - (unsigned long)hSession, (unsigned long)ulDataLen); - WOLFPKCS11_MSG(paramStr); + WOLFPKCS11_MSG(" hSession=%lu, ulDataLen=%lu", (unsigned long)hSession, (unsigned long)ulDataLen); } #endif @@ -4518,10 +4458,7 @@ CK_RV C_SignUpdate(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pPart, WOLFPKCS11_ENTER("C_SignUpdate"); #ifdef DEBUG_WOLFPKCS11 if (wolfpkcs11_debugging) { - char paramStr[256]; - snprintf(paramStr, sizeof(paramStr), " hSession=%lu, ulPartLen=%lu", - (unsigned long)hSession, (unsigned long)ulPartLen); - WOLFPKCS11_MSG(paramStr); + WOLFPKCS11_MSG(" hSession=%lu, ulPartLen=%lu", (unsigned long)hSession, (unsigned long)ulPartLen); } #endif @@ -4645,10 +4582,7 @@ CK_RV C_SignFinal(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pSignature, WOLFPKCS11_ENTER("C_SignFinal"); #ifdef DEBUG_WOLFPKCS11 if (wolfpkcs11_debugging) { - char paramStr[256]; - snprintf(paramStr, sizeof(paramStr), " hSession=%lu", - (unsigned long)hSession); - WOLFPKCS11_MSG(paramStr); + WOLFPKCS11_MSG(" hSession=%lu", (unsigned long)hSession); } #endif @@ -4791,10 +4725,7 @@ CK_RV C_SignRecoverInit(CK_SESSION_HANDLE hSession, WOLFPKCS11_ENTER("C_SignRecoverInit"); #ifdef DEBUG_WOLFPKCS11 if (wolfpkcs11_debugging) { - char paramStr[256]; - snprintf(paramStr, sizeof(paramStr), " hSession=%lu, hKey=%lu", - (unsigned long)hSession, (unsigned long)hKey); - WOLFPKCS11_MSG(paramStr); + WOLFPKCS11_MSG(" hSession=%lu, hKey=%lu", (unsigned long)hSession, (unsigned long)hKey); } #endif @@ -4853,10 +4784,7 @@ CK_RV C_SignRecover(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pData, WOLFPKCS11_ENTER("C_SignRecover"); #ifdef DEBUG_WOLFPKCS11 if (wolfpkcs11_debugging) { - char paramStr[256]; - snprintf(paramStr, sizeof(paramStr), " hSession=%lu, ulDataLen=%lu", - (unsigned long)hSession, (unsigned long)ulDataLen); - WOLFPKCS11_MSG(paramStr); + WOLFPKCS11_MSG(" hSession=%lu, ulDataLen=%lu", (unsigned long)hSession, (unsigned long)ulDataLen); } #endif @@ -4915,10 +4843,7 @@ CK_RV C_VerifyInit(CK_SESSION_HANDLE hSession, WOLFPKCS11_ENTER("C_VerifyInit"); #ifdef DEBUG_WOLFPKCS11 if (wolfpkcs11_debugging) { - char paramStr[256]; - snprintf(paramStr, sizeof(paramStr), " hSession=%lu, hKey=%lu", - (unsigned long)hSession, (unsigned long)hKey); - WOLFPKCS11_MSG(paramStr); + WOLFPKCS11_MSG(" hSession=%lu, hKey=%lu", (unsigned long)hSession, (unsigned long)hKey); } #endif @@ -5222,10 +5147,7 @@ CK_RV C_Verify(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pData, WOLFPKCS11_ENTER("C_Verify"); #ifdef DEBUG_WOLFPKCS11 if (wolfpkcs11_debugging) { - char paramStr[256]; - snprintf(paramStr, sizeof(paramStr), " hSession=%lu, ulDataLen=%lu, ulSignatureLen=%lu", - (unsigned long)hSession, (unsigned long)ulDataLen, (unsigned long)ulSignatureLen); - WOLFPKCS11_MSG(paramStr); + WOLFPKCS11_MSG(" hSession=%lu, ulDataLen=%lu, ulSignatureLen=%lu", (unsigned long)hSession, (unsigned long)ulDataLen, (unsigned long)ulSignatureLen); } #endif @@ -5500,10 +5422,7 @@ CK_RV C_VerifyUpdate(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pPart, WOLFPKCS11_ENTER("C_VerifyUpdate"); #ifdef DEBUG_WOLFPKCS11 if (wolfpkcs11_debugging) { - char paramStr[256]; - snprintf(paramStr, sizeof(paramStr), " hSession=%lu, ulPartLen=%lu", - (unsigned long)hSession, (unsigned long)ulPartLen); - WOLFPKCS11_MSG(paramStr); + WOLFPKCS11_MSG(" hSession=%lu, ulPartLen=%lu", (unsigned long)hSession, (unsigned long)ulPartLen); } #endif @@ -5621,10 +5540,7 @@ CK_RV C_VerifyFinal(CK_SESSION_HANDLE hSession, WOLFPKCS11_ENTER("C_VerifyFinal"); #ifdef DEBUG_WOLFPKCS11 if (wolfpkcs11_debugging) { - char paramStr[256]; - snprintf(paramStr, sizeof(paramStr), " hSession=%lu, ulSignatureLen=%lu", - (unsigned long)hSession, (unsigned long)ulSignatureLen); - WOLFPKCS11_MSG(paramStr); + WOLFPKCS11_MSG(" hSession=%lu, ulSignatureLen=%lu", (unsigned long)hSession, (unsigned long)ulSignatureLen); } #endif @@ -5745,10 +5661,7 @@ CK_RV C_VerifyRecoverInit(CK_SESSION_HANDLE hSession, WOLFPKCS11_ENTER("C_VerifyRecoverInit"); #ifdef DEBUG_WOLFPKCS11 if (wolfpkcs11_debugging) { - char paramStr[256]; - snprintf(paramStr, sizeof(paramStr), " hSession=%lu, hKey=%lu", - (unsigned long)hSession, (unsigned long)hKey); - WOLFPKCS11_MSG(paramStr); + WOLFPKCS11_MSG(" hSession=%lu, hKey=%lu", (unsigned long)hSession, (unsigned long)hKey); } #endif @@ -5848,10 +5761,7 @@ CK_RV C_VerifyRecover(CK_SESSION_HANDLE hSession, WOLFPKCS11_ENTER("C_VerifyRecover"); #ifdef DEBUG_WOLFPKCS11 if (wolfpkcs11_debugging) { - char paramStr[256]; - snprintf(paramStr, sizeof(paramStr), " hSession=%lu, ulSignatureLen=%lu", - (unsigned long)hSession, (unsigned long)ulSignatureLen); - WOLFPKCS11_MSG(paramStr); + WOLFPKCS11_MSG(" hSession=%lu, ulSignatureLen=%lu", (unsigned long)hSession, (unsigned long)ulSignatureLen); } #endif @@ -5946,10 +5856,7 @@ CK_RV C_DigestEncryptUpdate(CK_SESSION_HANDLE hSession, WOLFPKCS11_ENTER("C_DigestEncryptUpdate"); #ifdef DEBUG_WOLFPKCS11 if (wolfpkcs11_debugging) { - char paramStr[256]; - snprintf(paramStr, sizeof(paramStr), " hSession=%lu, ulPartLen=%lu", - (unsigned long)hSession, (unsigned long)ulPartLen); - WOLFPKCS11_MSG(paramStr); + WOLFPKCS11_MSG(" hSession=%lu, ulPartLen=%lu", (unsigned long)hSession, (unsigned long)ulPartLen); } #endif @@ -6004,10 +5911,7 @@ CK_RV C_DecryptDigestUpdate(CK_SESSION_HANDLE hSession, WOLFPKCS11_ENTER("C_DecryptDigestUpdate"); #ifdef DEBUG_WOLFPKCS11 if (wolfpkcs11_debugging) { - char paramStr[256]; - snprintf(paramStr, sizeof(paramStr), " hSession=%lu, ulEncryptedPartLen=%lu", - (unsigned long)hSession, (unsigned long)ulEncryptedPartLen); - WOLFPKCS11_MSG(paramStr); + WOLFPKCS11_MSG(" hSession=%lu, ulEncryptedPartLen=%lu", (unsigned long)hSession, (unsigned long)ulEncryptedPartLen); } #endif @@ -6064,10 +5968,7 @@ CK_RV C_SignEncryptUpdate(CK_SESSION_HANDLE hSession, WOLFPKCS11_ENTER("C_SignEncryptUpdate"); #ifdef DEBUG_WOLFPKCS11 if (wolfpkcs11_debugging) { - char paramStr[256]; - snprintf(paramStr, sizeof(paramStr), " hSession=%lu, ulPartLen=%lu", - (unsigned long)hSession, (unsigned long)ulPartLen); - WOLFPKCS11_MSG(paramStr); + WOLFPKCS11_MSG(" hSession=%lu, ulPartLen=%lu", (unsigned long)hSession, (unsigned long)ulPartLen); } #endif @@ -6122,10 +6023,7 @@ CK_RV C_DecryptVerifyUpdate(CK_SESSION_HANDLE hSession, WOLFPKCS11_ENTER("C_DecryptVerifyUpdate"); #ifdef DEBUG_WOLFPKCS11 if (wolfpkcs11_debugging) { - char paramStr[256]; - snprintf(paramStr, sizeof(paramStr), " hSession=%lu, ulEncryptedPartLen=%lu", - (unsigned long)hSession, (unsigned long)ulEncryptedPartLen); - WOLFPKCS11_MSG(paramStr); + WOLFPKCS11_MSG(" hSession=%lu, ulEncryptedPartLen=%lu", (unsigned long)hSession, (unsigned long)ulEncryptedPartLen); } #endif @@ -6190,10 +6088,7 @@ CK_RV C_GenerateKey(CK_SESSION_HANDLE hSession, WOLFPKCS11_ENTER("C_GenerateKey"); #ifdef DEBUG_WOLFPKCS11 if (wolfpkcs11_debugging) { - char paramStr[256]; - snprintf(paramStr, sizeof(paramStr), " hSession=%lu, ulCount=%lu", - (unsigned long)hSession, (unsigned long)ulCount); - WOLFPKCS11_MSG(paramStr); + WOLFPKCS11_MSG(" hSession=%lu, ulCount=%lu", (unsigned long)hSession, (unsigned long)ulCount); } #endif @@ -6335,10 +6230,7 @@ CK_RV C_GenerateKeyPair(CK_SESSION_HANDLE hSession, WOLFPKCS11_ENTER("C_GenerateKeyPair"); #ifdef DEBUG_WOLFPKCS11 if (wolfpkcs11_debugging) { - char paramStr[256]; - snprintf(paramStr, sizeof(paramStr), " hSession=%lu, ulPublicKeyAttributeCount=%lu, ulPrivateKeyAttributeCount=%lu", - (unsigned long)hSession, (unsigned long)ulPublicKeyAttributeCount, (unsigned long)ulPrivateKeyAttributeCount); - WOLFPKCS11_MSG(paramStr); + WOLFPKCS11_MSG(" hSession=%lu, ulPublicKeyAttributeCount=%lu, ulPrivateKeyAttributeCount=%lu", (unsigned long)hSession, (unsigned long)ulPublicKeyAttributeCount, (unsigned long)ulPrivateKeyAttributeCount); } #endif @@ -6520,10 +6412,7 @@ CK_RV C_WrapKey(CK_SESSION_HANDLE hSession, WOLFPKCS11_ENTER("C_WrapKey"); #ifdef DEBUG_WOLFPKCS11 if (wolfpkcs11_debugging) { - char paramStr[256]; - snprintf(paramStr, sizeof(paramStr), " hSession=%lu, hWrappingKey=%lu, hKey=%lu", - (unsigned long)hSession, (unsigned long)hWrappingKey, (unsigned long)hKey); - WOLFPKCS11_MSG(paramStr); + WOLFPKCS11_MSG(" hSession=%lu, hWrappingKey=%lu, hKey=%lu", (unsigned long)hSession, (unsigned long)hWrappingKey, (unsigned long)hKey); } #endif @@ -6693,10 +6582,7 @@ CK_RV C_UnwrapKey(CK_SESSION_HANDLE hSession, WOLFPKCS11_ENTER("C_UnwrapKey"); #ifdef DEBUG_WOLFPKCS11 if (wolfpkcs11_debugging) { - char paramStr[256]; - snprintf(paramStr, sizeof(paramStr), " hSession=%lu, hUnwrappingKey=%lu, ulWrappedKeyLen=%lu, ulAttributeCount=%lu", - (unsigned long)hSession, (unsigned long)hUnwrappingKey, (unsigned long)ulWrappedKeyLen, (unsigned long)ulAttributeCount); - WOLFPKCS11_MSG(paramStr); + WOLFPKCS11_MSG(" hSession=%lu, hUnwrappingKey=%lu, ulWrappedKeyLen=%lu, ulAttributeCount=%lu", (unsigned long)hSession, (unsigned long)hUnwrappingKey, (unsigned long)ulWrappedKeyLen, (unsigned long)ulAttributeCount); } #endif @@ -7063,10 +6949,7 @@ CK_RV C_DeriveKey(CK_SESSION_HANDLE hSession, WOLFPKCS11_ENTER("C_DeriveKey"); #ifdef DEBUG_WOLFPKCS11 if (wolfpkcs11_debugging) { - char paramStr[256]; - snprintf(paramStr, sizeof(paramStr), " hSession=%lu, hBaseKey=%lu, ulAttributeCount=%lu", - (unsigned long)hSession, (unsigned long)hBaseKey, (unsigned long)ulAttributeCount); - WOLFPKCS11_MSG(paramStr); + WOLFPKCS11_MSG(" hSession=%lu, hBaseKey=%lu, ulAttributeCount=%lu", (unsigned long)hSession, (unsigned long)hBaseKey, (unsigned long)ulAttributeCount); } #endif @@ -7388,10 +7271,7 @@ CK_RV C_SeedRandom(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pSeed, WOLFPKCS11_ENTER("C_SeedRandom"); #ifdef DEBUG_WOLFPKCS11 if (wolfpkcs11_debugging) { - char paramStr[256]; - snprintf(paramStr, sizeof(paramStr), " hSession=%lu, ulSeedLen=%lu", - (unsigned long)hSession, (unsigned long)ulSeedLen); - WOLFPKCS11_MSG(paramStr); + WOLFPKCS11_MSG(" hSession=%lu, ulSeedLen=%lu", (unsigned long)hSession, (unsigned long)ulSeedLen); } #endif @@ -7453,10 +7333,7 @@ CK_RV C_GenerateRandom(CK_SESSION_HANDLE hSession, WOLFPKCS11_ENTER("C_GenerateRandom"); #ifdef DEBUG_WOLFPKCS11 if (wolfpkcs11_debugging) { - char paramStr[256]; - snprintf(paramStr, sizeof(paramStr), " hSession=%lu, ulRandomLen=%lu", - (unsigned long)hSession, (unsigned long)ulRandomLen); - WOLFPKCS11_MSG(paramStr); + WOLFPKCS11_MSG(" hSession=%lu, ulRandomLen=%lu", (unsigned long)hSession, (unsigned long)ulRandomLen); } #endif diff --git a/wolfpkcs11/internal.h b/wolfpkcs11/internal.h index 852dc2ed..87f66e96 100644 --- a/wolfpkcs11/internal.h +++ b/wolfpkcs11/internal.h @@ -628,7 +628,7 @@ void wolfPKCS11_Debugging_Off(void); #endif #ifndef WOLFPKCS11_MSG #define WOLFPKCS11_MSG(fmt, ...) \ - do { if (wolfpkcs11_debugging) printf("WOLFPKCS11: " fmt "\n", ##__VA_ARGS__); } while(0) + do { if (wolfpkcs11_debugging) printf("WOLFPKCS11: " fmt "\n", __VA_ARGS__); } while(0) #endif #else #define WOLFPKCS11_ENTER(funcName) From 90f5b9c930d09db0146f3822262636c4739fc042 Mon Sep 17 00:00:00 2001 From: Devin AI <158243242+devin-ai-integration[bot]@users.noreply.github.com> Date: Fri, 20 Jun 2025 14:23:50 +0000 Subject: [PATCH 05/13] Improve debug_test.c with build integration and output verification - Add debug_test to tests/include.am for proper build and test integration - Return code 77 (skip test) when DEBUG_WOLFPKCS11 is not defined - Implement stdout capture mechanism to verify debug output is generated - Test passes/fails based on whether debug messages are actually produced - Follows wolfPKCS11 test framework patterns and conventions Co-Authored-By: andrew@wolfssl.com --- tests/debug_test.c | 90 +++++++++++++++++++++++++++++++--------------- tests/include.am | 6 ++++ 2 files changed, 67 insertions(+), 29 deletions(-) diff --git a/tests/debug_test.c b/tests/debug_test.c index f77c296c..84bdd5b9 100644 --- a/tests/debug_test.c +++ b/tests/debug_test.c @@ -1,13 +1,57 @@ #include +#include +#include #include "wolfpkcs11/pkcs11.h" +#ifdef DEBUG_WOLFPKCS11 +static int debug_output_detected = 0; +static FILE* original_stdout = NULL; +static FILE* capture_file = NULL; + +static void setup_output_capture(void) { + original_stdout = stdout; + capture_file = tmpfile(); + if (capture_file) { + stdout = capture_file; + } +} + +static int check_debug_output(void) { + char buffer[1024]; + int found_debug = 0; + + if (!capture_file) { + return 0; + } + + stdout = original_stdout; + rewind(capture_file); + + while (fgets(buffer, sizeof(buffer), capture_file)) { + if (strstr(buffer, "WOLFPKCS11 ENTER:") || + strstr(buffer, "WOLFPKCS11 LEAVE:") || + strstr(buffer, "WOLFPKCS11:")) { + found_debug = 1; + break; + } + } + + fclose(capture_file); + return found_debug; +} +#endif + int main() { CK_RV rv; CK_FUNCTION_LIST_PTR pFunctionList; - printf("=== wolfPKCS11 Debug Test Program ===\n"); +#ifndef DEBUG_WOLFPKCS11 + printf("Debug mode is DISABLED (DEBUG_WOLFPKCS11 not defined)\n"); + printf("Skipping debug test - returning code 77\n"); + return 77; +#else -#ifdef DEBUG_WOLFPKCS11 + printf("=== wolfPKCS11 Debug Test Program ===\n"); printf("Debug mode is ENABLED (DEBUG_WOLFPKCS11 defined)\n"); printf("\nTesting debug control functions:\n"); @@ -20,50 +64,38 @@ int main() { wolfPKCS11_Debugging_On(); printf("Debug re-enabled\n"); - printf("\nTesting PKCS#11 functions with debug output:\n"); + printf("\nTesting PKCS#11 functions with debug output capture:\n"); + + setup_output_capture(); + rv = C_GetFunctionList(&pFunctionList); - printf("C_GetFunctionList returned: %lu\n", (unsigned long)rv); if (rv == CKR_OK && pFunctionList != NULL) { rv = pFunctionList->C_Initialize(NULL); - printf("C_Initialize returned: %lu\n", (unsigned long)rv); if (rv == CKR_OK) { CK_INFO info; rv = pFunctionList->C_GetInfo(&info); - printf("C_GetInfo returned: %lu\n", (unsigned long)rv); - pFunctionList->C_Finalize(NULL); - printf("C_Finalize called\n"); } } + int debug_found = check_debug_output(); + + printf("C_GetFunctionList returned: %lu\n", (unsigned long)rv); + printf("Debug output detection: %s\n", debug_found ? "PASS" : "FAIL"); + wolfPKCS11_Debugging_Off(); printf("Debug disabled at end\n"); -#else - printf("Debug mode is DISABLED (DEBUG_WOLFPKCS11 not defined)\n"); - printf("Debug functions and macros are compiled out\n"); - - printf("\nTesting PKCS#11 functions without debug output:\n"); - rv = C_GetFunctionList(&pFunctionList); - printf("C_GetFunctionList returned: %lu\n", (unsigned long)rv); + printf("\n=== Test Complete ===\n"); - if (rv == CKR_OK && pFunctionList != NULL) { - rv = pFunctionList->C_Initialize(NULL); - printf("C_Initialize returned: %lu\n", (unsigned long)rv); - - if (rv == CKR_OK) { - CK_INFO info; - rv = pFunctionList->C_GetInfo(&info); - printf("C_GetInfo returned: %lu\n", (unsigned long)rv); - - pFunctionList->C_Finalize(NULL); - printf("C_Finalize called\n"); - } + if (!debug_found) { + printf("ERROR: No debug output was detected during PKCS#11 function calls\n"); + return 1; } -#endif - printf("\n=== Test Complete ===\n"); + printf("SUCCESS: Debug output was properly generated\n"); return 0; +#endif } diff --git a/tests/include.am b/tests/include.am index 8bfcfedd..35d196f9 100644 --- a/tests/include.am +++ b/tests/include.am @@ -26,12 +26,18 @@ noinst_PROGRAMS += tests/rsa_session_persistence_test tests_rsa_session_persistence_test_SOURCES = tests/rsa_session_persistence_test.c tests_rsa_session_persistence_test_LDADD = +check_PROGRAMS += tests/debug_test +noinst_PROGRAMS += tests/debug_test +tests_debug_test_SOURCES = tests/debug_test.c +tests_debug_test_LDADD = + if BUILD_STATIC tests_pkcs11test_LDADD += src/libwolfpkcs11.la tests_pkcs11mtt_LDADD += src/libwolfpkcs11.la tests_pkcs11str_LDADD += src/libwolfpkcs11.la tests_token_path_test_LDADD += src/libwolfpkcs11.la tests_rsa_session_persistence_test_LDADD += src/libwolfpkcs11.la +tests_debug_test_LDADD += src/libwolfpkcs11.la endif EXTRA_DIST += tests/unit.h \ From 0e1c009c88b94b4a665c8394c56c67fc63e3d5ec Mon Sep 17 00:00:00 2001 From: Devin AI <158243242+devin-ai-integration[bot]@users.noreply.github.com> Date: Fri, 20 Jun 2025 14:28:43 +0000 Subject: [PATCH 06/13] Fix debug_test.c compilation errors - Change main() to main(void) to fix strict-prototypes warning - Remove unused debug_output_detected variable - Addresses CI build failures caused by -Werror treating warnings as errors Co-Authored-By: andrew@wolfssl.com --- tests/debug_test.c | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/tests/debug_test.c b/tests/debug_test.c index 84bdd5b9..31755aa9 100644 --- a/tests/debug_test.c +++ b/tests/debug_test.c @@ -4,7 +4,6 @@ #include "wolfpkcs11/pkcs11.h" #ifdef DEBUG_WOLFPKCS11 -static int debug_output_detected = 0; static FILE* original_stdout = NULL; static FILE* capture_file = NULL; @@ -41,7 +40,7 @@ static int check_debug_output(void) { } #endif -int main() { +int main(void) { CK_RV rv; CK_FUNCTION_LIST_PTR pFunctionList; From 5e8c72a678b20037db4a42a9cb319e6fc41de782 Mon Sep 17 00:00:00 2001 From: Devin AI <158243242+devin-ai-integration[bot]@users.noreply.github.com> Date: Fri, 20 Jun 2025 14:39:22 +0000 Subject: [PATCH 07/13] Fix debug_test.c unused variables and linking issues - Move variable declarations inside DEBUG_WOLFPKCS11 ifdef to avoid unused variable errors in non-debug builds - Ensure debug_test links against libwolfpkcs11.la in both static and dynamic builds Co-Authored-By: andrew@wolfssl.com --- tests/debug_test.c | 5 ++--- tests/include.am | 2 ++ 2 files changed, 4 insertions(+), 3 deletions(-) diff --git a/tests/debug_test.c b/tests/debug_test.c index 31755aa9..23c67cfe 100644 --- a/tests/debug_test.c +++ b/tests/debug_test.c @@ -41,14 +41,13 @@ static int check_debug_output(void) { #endif int main(void) { - CK_RV rv; - CK_FUNCTION_LIST_PTR pFunctionList; - #ifndef DEBUG_WOLFPKCS11 printf("Debug mode is DISABLED (DEBUG_WOLFPKCS11 not defined)\n"); printf("Skipping debug test - returning code 77\n"); return 77; #else + CK_RV rv; + CK_FUNCTION_LIST_PTR pFunctionList; printf("=== wolfPKCS11 Debug Test Program ===\n"); printf("Debug mode is ENABLED (DEBUG_WOLFPKCS11 defined)\n"); diff --git a/tests/include.am b/tests/include.am index 35d196f9..6bcfe422 100644 --- a/tests/include.am +++ b/tests/include.am @@ -38,6 +38,8 @@ tests_pkcs11str_LDADD += src/libwolfpkcs11.la tests_token_path_test_LDADD += src/libwolfpkcs11.la tests_rsa_session_persistence_test_LDADD += src/libwolfpkcs11.la tests_debug_test_LDADD += src/libwolfpkcs11.la +else +tests_debug_test_LDADD += src/libwolfpkcs11.la endif EXTRA_DIST += tests/unit.h \ From 12fee46809340a8645d24cf0a6be1a543da30b00 Mon Sep 17 00:00:00 2001 From: Devin AI <158243242+devin-ai-integration[bot]@users.noreply.github.com> Date: Fri, 20 Jun 2025 15:20:39 +0000 Subject: [PATCH 08/13] Address dgarske's code style review comments - Add standard wolfSSL GPL license header to debug_test.c with 2025 copyright - Fix function brace style (braces on their own lines) - Fix mixed variable declarations (move declarations to top of blocks) - Fix line length violations (break long lines under 80 chars) - Update copyright year in crypto.c from 2023 to 2025 Co-Authored-By: andrew@wolfssl.com --- src/crypto.c | 14 ++++++++++---- tests/debug_test.c | 34 ++++++++++++++++++++++++++++++---- 2 files changed, 40 insertions(+), 8 deletions(-) diff --git a/src/crypto.c b/src/crypto.c index ca6c80fe..25545afd 100644 --- a/src/crypto.c +++ b/src/crypto.c @@ -1,6 +1,6 @@ /* crypto.c * - * Copyright (C) 2006-2023 wolfSSL Inc. + * Copyright (C) 2006-2025 wolfSSL Inc. * * This file is part of wolfPKCS11. * @@ -1088,7 +1088,9 @@ CK_RV C_CopyObject(CK_SESSION_HANDLE hSession, CK_OBJECT_HANDLE hObject, WOLFPKCS11_ENTER("C_CopyObject"); #ifdef DEBUG_WOLFPKCS11 if (wolfpkcs11_debugging) { - WOLFPKCS11_MSG(" hSession=%lu, hObject=%lu, ulCount=%lu", (unsigned long)hSession, (unsigned long)hObject, (unsigned long)ulCount); + WOLFPKCS11_MSG(" hSession=%lu, hObject=%lu, ulCount=%lu", + (unsigned long)hSession, (unsigned long)hObject, + (unsigned long)ulCount); } #endif @@ -1310,7 +1312,9 @@ CK_RV C_GetAttributeValue(CK_SESSION_HANDLE hSession, WOLFPKCS11_ENTER("C_GetAttributeValue"); #ifdef DEBUG_WOLFPKCS11 if (wolfpkcs11_debugging) { - WOLFPKCS11_MSG(" hSession=%lu, hObject=%lu, ulCount=%lu", (unsigned long)hSession, (unsigned long)hObject, (unsigned long)ulCount); + WOLFPKCS11_MSG(" hSession=%lu, hObject=%lu, ulCount=%lu", + (unsigned long)hSession, (unsigned long)hObject, + (unsigned long)ulCount); } #endif @@ -1410,7 +1414,9 @@ CK_RV C_SetAttributeValue(CK_SESSION_HANDLE hSession, WOLFPKCS11_ENTER("C_SetAttributeValue"); #ifdef DEBUG_WOLFPKCS11 if (wolfpkcs11_debugging) { - WOLFPKCS11_MSG(" hSession=%lu, hObject=%lu, ulCount=%lu", (unsigned long)hSession, (unsigned long)hObject, (unsigned long)ulCount); + WOLFPKCS11_MSG(" hSession=%lu, hObject=%lu, ulCount=%lu", + (unsigned long)hSession, (unsigned long)hObject, + (unsigned long)ulCount); } #endif diff --git a/tests/debug_test.c b/tests/debug_test.c index 23c67cfe..578c3ec1 100644 --- a/tests/debug_test.c +++ b/tests/debug_test.c @@ -1,3 +1,25 @@ +/* debug_test.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 + */ + + #include #include #include @@ -7,7 +29,8 @@ static FILE* original_stdout = NULL; static FILE* capture_file = NULL; -static void setup_output_capture(void) { +static void setup_output_capture(void) +{ original_stdout = stdout; capture_file = tmpfile(); if (capture_file) { @@ -15,7 +38,8 @@ static void setup_output_capture(void) { } } -static int check_debug_output(void) { +static int check_debug_output(void) +{ char buffer[1024]; int found_debug = 0; @@ -40,7 +64,8 @@ static int check_debug_output(void) { } #endif -int main(void) { +int main(void) +{ #ifndef DEBUG_WOLFPKCS11 printf("Debug mode is DISABLED (DEBUG_WOLFPKCS11 not defined)\n"); printf("Skipping debug test - returning code 77\n"); @@ -48,6 +73,7 @@ int main(void) { #else CK_RV rv; CK_FUNCTION_LIST_PTR pFunctionList; + int debug_found; printf("=== wolfPKCS11 Debug Test Program ===\n"); printf("Debug mode is ENABLED (DEBUG_WOLFPKCS11 defined)\n"); @@ -78,7 +104,7 @@ int main(void) { } } - int debug_found = check_debug_output(); + debug_found = check_debug_output(); printf("C_GetFunctionList returned: %lu\n", (unsigned long)rv); printf("Debug output detection: %s\n", debug_found ? "PASS" : "FAIL"); From f9a51d2516672d6876a7ddff63345e6f7a322def Mon Sep 17 00:00:00 2001 From: Devin AI <158243242+devin-ai-integration[bot]@users.noreply.github.com> Date: Fri, 20 Jun 2025 15:37:14 +0000 Subject: [PATCH 09/13] Address dgarske's latest review comments - Replace printf with WOLFPKCS11_MSG in wolfPKCS11_Debugging_On() - Replace printf with WOLFPKCS11_MSG in wolfPKCS11_Debugging_Off() - Ensures consistent debug output formatting across all debug functions Co-Authored-By: andrew@wolfssl.com --- src/internal.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/internal.c b/src/internal.c index 32397892..75c8ba2b 100644 --- a/src/internal.c +++ b/src/internal.c @@ -170,12 +170,12 @@ int wolfpkcs11_debugging = 0; void wolfPKCS11_Debugging_On(void) { wolfpkcs11_debugging = 1; - printf("wolfPKCS11 debug logging enabled\n"); + WOLFPKCS11_MSG("debug logging enabled"); } void wolfPKCS11_Debugging_Off(void) { - printf("wolfPKCS11 debug logging disabled\n"); + WOLFPKCS11_MSG("debug logging disabled"); wolfpkcs11_debugging = 0; } #endif From 227a2e209c97a227c2b8697ef9c273d64be8e4f1 Mon Sep 17 00:00:00 2001 From: Devin AI <158243242+devin-ai-integration[bot]@users.noreply.github.com> Date: Fri, 20 Jun 2025 15:41:06 +0000 Subject: [PATCH 10/13] Fix WOLFPKCS11_MSG macro to handle cases with no arguments - Add ## before __VA_ARGS__ to handle empty argument lists - Fixes compilation errors in wolfPKCS11_Debugging_On() and wolfPKCS11_Debugging_Off() - Resolves CI build failures reported by andrew@wolfssl.com Co-Authored-By: andrew@wolfssl.com --- wolfpkcs11/internal.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/wolfpkcs11/internal.h b/wolfpkcs11/internal.h index 87f66e96..852dc2ed 100644 --- a/wolfpkcs11/internal.h +++ b/wolfpkcs11/internal.h @@ -628,7 +628,7 @@ void wolfPKCS11_Debugging_Off(void); #endif #ifndef WOLFPKCS11_MSG #define WOLFPKCS11_MSG(fmt, ...) \ - do { if (wolfpkcs11_debugging) printf("WOLFPKCS11: " fmt "\n", __VA_ARGS__); } while(0) + do { if (wolfpkcs11_debugging) printf("WOLFPKCS11: " fmt "\n", ##__VA_ARGS__); } while(0) #endif #else #define WOLFPKCS11_ENTER(funcName) From cd8fc4a4733e24f7e34b2b08e08e2625f90a6c71 Mon Sep 17 00:00:00 2001 From: Devin AI <158243242+devin-ai-integration[bot]@users.noreply.github.com> Date: Fri, 20 Jun 2025 15:47:23 +0000 Subject: [PATCH 11/13] Make debug control functions available in non-debug builds - Add no-op versions of wolfPKCS11_Debugging_On() and wolfPKCS11_Debugging_Off() - Functions now exist in both debug and non-debug modes - Addresses andrew@wolfssl.com feedback for consistent API availability Co-Authored-By: andrew@wolfssl.com --- src/internal.c | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/src/internal.c b/src/internal.c index 75c8ba2b..e836a592 100644 --- a/src/internal.c +++ b/src/internal.c @@ -178,6 +178,14 @@ void wolfPKCS11_Debugging_Off(void) WOLFPKCS11_MSG("debug logging disabled"); wolfpkcs11_debugging = 0; } +#else +void wolfPKCS11_Debugging_On(void) +{ +} + +void wolfPKCS11_Debugging_Off(void) +{ +} #endif From 2ae95641460feed31c65dbaa2e4f1fc77093595b Mon Sep 17 00:00:00 2001 From: Devin AI <158243242+devin-ai-integration[bot]@users.noreply.github.com> Date: Fri, 20 Jun 2025 15:49:31 +0000 Subject: [PATCH 12/13] Declare debug control functions in header for all builds - Move wolfPKCS11_Debugging_On() and wolfPKCS11_Debugging_Off() declarations outside #ifdef DEBUG_WOLFPKCS11 block - Functions are now available in both debug and non-debug builds - Addresses feedback from andrew@wolfssl.com Co-Authored-By: andrew@wolfssl.com --- wolfpkcs11/internal.h | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/wolfpkcs11/internal.h b/wolfpkcs11/internal.h index 852dc2ed..d1c84fb7 100644 --- a/wolfpkcs11/internal.h +++ b/wolfpkcs11/internal.h @@ -613,11 +613,12 @@ int WP11_GetOperationState(WP11_Session* session, unsigned char* stateData, int WP11_SetOperationState(WP11_Session* session, unsigned char* stateData, unsigned long stateDataLen); -#ifdef DEBUG_WOLFPKCS11 -extern int wolfpkcs11_debugging; void wolfPKCS11_Debugging_On(void); void wolfPKCS11_Debugging_Off(void); +#ifdef DEBUG_WOLFPKCS11 +extern int wolfpkcs11_debugging; + #ifndef WOLFPKCS11_ENTER #define WOLFPKCS11_ENTER(funcName) \ do { if (wolfpkcs11_debugging) printf("WOLFPKCS11 ENTER: %s\n", funcName); } while(0) From de458ffab69933b8eb289f57c957c64d3034e8b8 Mon Sep 17 00:00:00 2001 From: Devin AI <158243242+devin-ai-integration[bot]@users.noreply.github.com> Date: Fri, 20 Jun 2025 16:20:23 +0000 Subject: [PATCH 13/13] Add --enable-debug to CI test matrix - Add new 'debug' job to unit-test.yml with --enable-debug configuration - Ensures debug messaging system is tested in CI - Addresses request from andrew@wolfssl.com Co-Authored-By: andrew@wolfssl.com --- .github/workflows/unit-test.yml | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/.github/workflows/unit-test.yml b/.github/workflows/unit-test.yml index 2a7c5bbc..efef2261 100644 --- a/.github/workflows/unit-test.yml +++ b/.github/workflows/unit-test.yml @@ -83,6 +83,11 @@ jobs: with: config: --enable-nss + debug: + uses: ./.github/workflows/build-workflow.yml + with: + config: --enable-debug + #TODO: --disable-aes Enable AES (default: enabled) #TODO: --disable-aescbc Enable AES-CBC (default: enabled) #TODO: --disable-sha256 Enable SHA-256 (default: enabled)