Implement HW/SW crypto affinity

Author: AlexLanzano

.gitignore

@@ -9,6 +9,7 @@ tools/testcertgen/*.der
 *.code-workspace
 .vscode
 compile_commands.json
+.cache
 
 # Static analysis
 tools/static-analysis/reports/

docs/draft/crypto_affinity.md

@@ -0,0 +1,92 @@
+# SetCryptoAffinity Client API
+
+The SetCryptoAffinity feature allows a client to control whether the server uses **software** or **hardware** cryptographic implementations.
+
+## Affinity Values
+
+```c
+enum WH_CRYPTO_AFFINITY_ENUM {
+    WH_CRYPTO_AFFINITY_SW = 0,  // Use software crypto (devId = INVALID_DEVID)
+    WH_CRYPTO_AFFINITY_HW = 1,  // Use hardware crypto (devId = configured value)
+};
+```
+
+## Client API Functions
+
+### Blocking API (simplest)
+
+```c
+int wh_Client_SetCryptoAffinity(whClientContext* c, uint32_t affinity,
+        int32_t* out_rc, uint32_t* out_affinity);
+```
+
+### Non-blocking (async) API
+
+```c
+// Send request
+int wh_Client_SetCryptoAffinityRequest(whClientContext* c, uint32_t affinity);
+
+// Receive response
+int wh_Client_SetCryptoAffinityResponse(whClientContext* c, int32_t* out_rc,
+        uint32_t* out_affinity);
+```
+
+## Usage Example
+
+```c
+int32_t  server_rc;
+uint32_t current_affinity;
+
+// Switch to software crypto
+int rc = wh_Client_SetCryptoAffinity(client,
+        WH_CRYPTO_AFFINITY_SW,
+        &server_rc,
+        &current_affinity);
+
+if (rc == WH_ERROR_OK && server_rc == WH_ERROR_OK) {
+    // Server is now using software crypto
+    // current_affinity == WH_CRYPTO_AFFINITY_SW
+}
+
+// Switch to hardware crypto
+rc = wh_Client_SetCryptoAffinity(client,
+        WH_CRYPTO_AFFINITY_HW,
+        &server_rc,
+        &current_affinity);
+
+if (rc == WH_ERROR_OK) {
+    if (server_rc == WH_ERROR_OK) {
+        // Server is now using hardware crypto
+    } else if (server_rc == WH_ERROR_BADCONFIG) {
+        // HW crypto not available (server wasn't configured with a valid devId)
+    }
+}
+```
+
+## Return Values
+
+| Value | Description |
+|-------|-------------|
+| `rc` (function return) | Transport/communication errors |
+| `server_rc` (output parameter) | Server-side result |
+
+### Server Return Codes
+
+| Code | Description |
+|------|-------------|
+| `WH_ERROR_OK` | Affinity changed successfully |
+| `WH_ERROR_BADCONFIG` | HW requested but no HW crypto configured |
+| `WH_ERROR_BADARGS` | Invalid affinity value |
+| `WH_ERROR_ABORTED` | Server crypto context is NULL |
+| `WH_ERROR_NOTIMPL` | Affinity change not implemented (returned when `WOLF_CRYPTO_CB` is not defined and HW affinity is requested, or when `WOLFHSM_CFG_NO_CRYPTO` is defined) |
+
+## Server Behavior
+
+When affinity is set:
+
+| Affinity | Server Action |
+|----------|---------------|
+| `WH_CRYPTO_AFFINITY_SW` | `server->crypto->devId = INVALID_DEVID` (wolfCrypt uses software) |
+| `WH_CRYPTO_AFFINITY_HW` | `server->crypto->devId = server->crypto->configDevId` (wolfCrypt uses registered crypto callback) |
+
+The `configDevId` is stored at server init from `config->devId`.

src/wh_client.c

@@ -414,6 +414,75 @@ int wh_Client_CommInfo(whClientContext* c,
     return rc;
 }
 
+int wh_Client_SetCryptoAffinityRequest(whClientContext* c, uint32_t affinity)
+{
+    whMessageCommSetCryptoAffinityRequest msg = {0};
+
+    if (c == NULL) {
+        return WH_ERROR_BADARGS;
+    }
+
+    msg.affinity = affinity;
+
+    return wh_Client_SendRequest(c, WH_MESSAGE_GROUP_COMM,
+                                 WH_MESSAGE_COMM_ACTION_SET_CRYPTO_AFFINITY,
+                                 sizeof(msg), &msg);
+}
+
+int wh_Client_SetCryptoAffinityResponse(whClientContext* c, int32_t* out_rc,
+                                        uint32_t* out_affinity)
+{
+    int                                    rc          = 0;
+    whMessageCommSetCryptoAffinityResponse msg         = {0};
+    uint16_t                               resp_group  = 0;
+    uint16_t                               resp_action = 0;
+    uint16_t                               resp_size   = 0;
+
+    if (c == NULL) {
+        return WH_ERROR_BADARGS;
+    }
+
+    rc = wh_Client_RecvResponse(c, &resp_group, &resp_action, &resp_size, &msg);
+    if (rc == 0) {
+        /* Validate response */
+        if ((resp_group != WH_MESSAGE_GROUP_COMM) ||
+            (resp_action != WH_MESSAGE_COMM_ACTION_SET_CRYPTO_AFFINITY) ||
+            (resp_size != sizeof(msg))) {
+            /* Invalid message */
+            rc = WH_ERROR_ABORTED;
+        }
+        else {
+            /* Valid message */
+            if (out_rc != NULL) {
+                *out_rc = msg.rc;
+            }
+            if (out_affinity != NULL) {
+                *out_affinity = msg.affinity;
+            }
+        }
+    }
+    return rc;
+}
+
+int wh_Client_SetCryptoAffinity(whClientContext* c, uint32_t affinity,
+                                int32_t* out_rc, uint32_t* out_affinity)
+{
+    int rc = 0;
+    if (c == NULL) {
+        return WH_ERROR_BADARGS;
+    }
+    do {
+        rc = wh_Client_SetCryptoAffinityRequest(c, affinity);
+    } while (rc == WH_ERROR_NOTREADY);
+
+    if (rc == 0) {
+        do {
+            rc = wh_Client_SetCryptoAffinityResponse(c, out_rc, out_affinity);
+        } while (rc == WH_ERROR_NOTREADY);
+    }
+    return rc;
+}
+
 
 int wh_Client_CommCloseRequest(whClientContext* c)
 {

src/wh_message_comm.c

@@ -83,4 +83,25 @@ int wh_MessageComm_TranslateInfoResponse(uint16_t magic,
     return 0;
 }
 
+int wh_MessageComm_TranslateSetCryptoAffinityRequest(
+    uint16_t magic, const whMessageCommSetCryptoAffinityRequest* src,
+    whMessageCommSetCryptoAffinityRequest* dest)
+{
+    if ((src == NULL) || (dest == NULL)) {
+        return WH_ERROR_BADARGS;
+    }
+    WH_T32(magic, dest, src, affinity);
+    return 0;
+}
 
+int wh_MessageComm_TranslateSetCryptoAffinityResponse(
+    uint16_t magic, const whMessageCommSetCryptoAffinityResponse* src,
+    whMessageCommSetCryptoAffinityResponse* dest)
+{
+    if ((src == NULL) || (dest == NULL)) {
+        return WH_ERROR_BADARGS;
+    }
+    WH_T32(magic, dest, src, rc);
+    WH_T32(magic, dest, src, affinity);
+    return 0;
+}

src/wh_server.c

@@ -81,8 +81,10 @@ int wh_Server_Init(whServerContext* server, whServerConfig* config)
     if (server->crypto != NULL) {
 #if defined(WOLF_CRYPTO_CB)
         server->crypto->devId = config->devId;
+        server->crypto->configDevId = config->devId;
 #else
         server->crypto->devId = INVALID_DEVID;
+        server->crypto->configDevId = INVALID_DEVID;
 #endif
     }
 #ifdef WOLFHSM_CFG_SHE_EXTENSION
@@ -266,6 +268,56 @@ static int _wh_Server_HandleCommRequest(whServerContext* server,
         *out_resp_size = sizeof(resp);
     }; break;
 
+    case WH_MESSAGE_COMM_ACTION_SET_CRYPTO_AFFINITY: {
+        whMessageCommSetCryptoAffinityRequest  req  = {0};
+        whMessageCommSetCryptoAffinityResponse resp = {0};
+
+        wh_MessageComm_TranslateSetCryptoAffinityRequest(
+            magic, (const whMessageCommSetCryptoAffinityRequest*)req_packet,
+            &req);
+
+#ifndef WOLFHSM_CFG_NO_CRYPTO
+        if (server->crypto == NULL) {
+            resp.rc       = WH_ERROR_ABORTED;
+            resp.affinity = WH_CRYPTO_AFFINITY_SW;
+        }
+        else {
+            switch (req.affinity) {
+                case WH_CRYPTO_AFFINITY_SW:
+                    server->crypto->devId = INVALID_DEVID;
+                    resp.rc               = WH_ERROR_OK;
+                    break;
+                case WH_CRYPTO_AFFINITY_HW:
+#ifdef WOLF_CRYPTO_CB
+                    if (server->crypto->configDevId != INVALID_DEVID) {
+                        server->crypto->devId = server->crypto->configDevId;
+                        resp.rc               = WH_ERROR_OK;
+                    }
+                    else {
+                        resp.rc = WH_ERROR_BADCONFIG;
+                    }
+                    break;
+#else
+                    resp.rc = WH_ERROR_NOTIMPL;
+                    break;
+#endif
+                default:
+                    resp.rc = WH_ERROR_BADARGS;
+                    break;
+            }
+            resp.affinity = (server->crypto->devId == INVALID_DEVID)
+                                ? WH_CRYPTO_AFFINITY_SW
+                                : WH_CRYPTO_AFFINITY_HW;
+        }
+#else
+        resp.rc       = WH_ERROR_NOTIMPL;
+        resp.affinity = WH_CRYPTO_AFFINITY_SW;
+#endif
+
+        wh_MessageComm_TranslateSetCryptoAffinityResponse(
+            magic, &resp, (whMessageCommSetCryptoAffinityResponse*)resp_packet);
+        *out_resp_size = sizeof(resp);
+    }; break;
 
     case WH_MESSAGE_COMM_ACTION_CLOSE:
     {

test/wh_test.c

@@ -42,6 +42,7 @@
 #include "wh_test_log.h"
 #include "wh_test_lock.h"
 #include "wh_test_posix_threadsafe_stress.h"
+#include "wh_test_crypto_affinity.h"
 
 #if defined(WOLFHSM_CFG_CERTIFICATE_MANAGER)
 #include "wh_test_cert.h"
@@ -93,6 +94,10 @@ int whTest_Unit(void)
     /* Crypto Tests */
     WH_TEST_ASSERT(0 == whTest_Crypto());
 
+#ifdef WOLF_CRYPTO_CB
+    WH_TEST_ASSERT(0 == whTest_CryptoAffinity());
+#endif
+
 #if defined(WOLFHSM_CFG_SERVER_IMG_MGR) && !defined(WOLFHSM_CFG_NO_CRYPTO)
     /* Image Manager Tests */
     WH_TEST_ASSERT(0 == whTest_ServerImgMgr(WH_NVM_TEST_BACKEND_FLASH));

test/wh_test_check_struct_padding.c

@@ -27,10 +27,12 @@
 
 
 #include "wolfhsm/wh_message_comm.h"
-whMessageComm_ErrorResponse whMessageComm_ErrorResponse_test;
-whMessageCommInitRequest    whMessageCommInitRequest_test;
-whMessageCommInitResponse   whMessageCommInitResponse_test;
-whMessageCommInfoResponse   whMessageCommInfoResponse_test;
+whMessageComm_ErrorResponse             whMessageComm_ErrorResponse_test;
+whMessageCommInitRequest                whMessageCommInitRequest_test;
+whMessageCommInitResponse               whMessageCommInitResponse_test;
+whMessageCommInfoResponse               whMessageCommInfoResponse_test;
+whMessageCommSetCryptoAffinityRequest   whMessageCommSetCryptoAffinityRequest_test;
+whMessageCommSetCryptoAffinityResponse  whMessageCommSetCryptoAffinityResponse_test;
 
 #include "wolfhsm/wh_message_customcb.h"
 whMessageCustomCb_Request  whMessageCustomCb_Request_test;